client_with_responses_interface.go

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

package mocks

import (
	context "context"

	api "github.com/kyma-project/eventing-auth-manager/internal/ias/internal/api"

	io "io"

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

	uuid "github.com/google/uuid"
)

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

type ClientWithResponsesInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *ClientWithResponsesInterface) EXPECT() *ClientWithResponsesInterface_Expecter {
	return &ClientWithResponsesInterface_Expecter{mock: &_m.Mock}
}

// CreateApiSecretWithBodyWithResponse provides a mock function with given fields: ctx, applicationIdentifier, contentType, body, reqEditors
func (_m *ClientWithResponsesInterface) CreateApiSecretWithBodyWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, contentType string, body io.Reader, reqEditors ...api.RequestEditorFn) (*api.CreateApiSecretResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

	return r0, r1
}

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

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

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

func (_c *ClientWithResponsesInterface_CreateApiSecretWithBodyWithResponse_Call) Return(_a0 *api.CreateApiSecretResponse, _a1 error) *ClientWithResponsesInterface_CreateApiSecretWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_CreateApiSecretWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, string, io.Reader, ...api.RequestEditorFn) (*api.CreateApiSecretResponse, error)) *ClientWithResponsesInterface_CreateApiSecretWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApiSecretWithResponse provides a mock function with given fields: ctx, applicationIdentifier, body, reqEditors
func (_m *ClientWithResponsesInterface) CreateApiSecretWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, body api.ApiSecretData, reqEditors ...api.RequestEditorFn) (*api.CreateApiSecretResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

	return r0, r1
}

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

// CreateApiSecretWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - body api.ApiSecretData
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) CreateApiSecretWithResponse(ctx interface{}, applicationIdentifier interface{}, body interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_CreateApiSecretWithResponse_Call {
	return &ClientWithResponsesInterface_CreateApiSecretWithResponse_Call{Call: _e.mock.On("CreateApiSecretWithResponse",
		append([]interface{}{ctx, applicationIdentifier, body}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_CreateApiSecretWithResponse_Call) Return(_a0 *api.CreateApiSecretResponse, _a1 error) *ClientWithResponsesInterface_CreateApiSecretWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_CreateApiSecretWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, api.ApiSecretData, ...api.RequestEditorFn) (*api.CreateApiSecretResponse, error)) *ClientWithResponsesInterface_CreateApiSecretWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

	return r0, r1
}

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

// CreateApplicationWithBodyWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - params *api.CreateApplicationParams
//   - contentType string
//   - body io.Reader
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) CreateApplicationWithBodyWithResponse(ctx interface{}, params interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_CreateApplicationWithBodyWithResponse_Call {
	return &ClientWithResponsesInterface_CreateApplicationWithBodyWithResponse_Call{Call: _e.mock.On("CreateApplicationWithBodyWithResponse",
		append([]interface{}{ctx, params, contentType, body}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_CreateApplicationWithBodyWithResponse_Call) Return(_a0 *api.CreateApplicationResponse, _a1 error) *ClientWithResponsesInterface_CreateApplicationWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_CreateApplicationWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, *api.CreateApplicationParams, string, io.Reader, ...api.RequestEditorFn) (*api.CreateApplicationResponse, error)) *ClientWithResponsesInterface_CreateApplicationWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// CreateApplicationWithResponse provides a mock function with given fields: ctx, params, body, reqEditors
func (_m *ClientWithResponsesInterface) CreateApplicationWithResponse(ctx context.Context, params *api.CreateApplicationParams, body api.Application, reqEditors ...api.RequestEditorFn) (*api.CreateApplicationResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, params, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *api.CreateApplicationResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *api.CreateApplicationParams, api.Application, ...api.RequestEditorFn) (*api.CreateApplicationResponse, error)); ok {
		return rf(ctx, params, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *api.CreateApplicationParams, api.Application, ...api.RequestEditorFn) *api.CreateApplicationResponse); ok {
		r0 = rf(ctx, params, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*api.CreateApplicationResponse)
		}
	}

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

	return r0, r1
}

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

// CreateApplicationWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - params *api.CreateApplicationParams
//   - body api.Application
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) CreateApplicationWithResponse(ctx interface{}, params interface{}, body interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_CreateApplicationWithResponse_Call {
	return &ClientWithResponsesInterface_CreateApplicationWithResponse_Call{Call: _e.mock.On("CreateApplicationWithResponse",
		append([]interface{}{ctx, params, body}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_CreateApplicationWithResponse_Call) Return(_a0 *api.CreateApplicationResponse, _a1 error) *ClientWithResponsesInterface_CreateApplicationWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_CreateApplicationWithResponse_Call) RunAndReturn(run func(context.Context, *api.CreateApplicationParams, api.Application, ...api.RequestEditorFn) (*api.CreateApplicationResponse, error)) *ClientWithResponsesInterface_CreateApplicationWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteApiSecretWithResponse provides a mock function with given fields: ctx, applicationIdentifier, params, reqEditors
func (_m *ClientWithResponsesInterface) DeleteApiSecretWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, params *api.DeleteApiSecretParams, reqEditors ...api.RequestEditorFn) (*api.DeleteApiSecretResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID, *api.DeleteApiSecretParams, ...api.RequestEditorFn) error); ok {
		r1 = rf(ctx, applicationIdentifier, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DeleteApiSecretWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - params *api.DeleteApiSecretParams
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) DeleteApiSecretWithResponse(ctx interface{}, applicationIdentifier interface{}, params interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_DeleteApiSecretWithResponse_Call {
	return &ClientWithResponsesInterface_DeleteApiSecretWithResponse_Call{Call: _e.mock.On("DeleteApiSecretWithResponse",
		append([]interface{}{ctx, applicationIdentifier, params}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_DeleteApiSecretWithResponse_Call) Return(_a0 *api.DeleteApiSecretResponse, _a1 error) *ClientWithResponsesInterface_DeleteApiSecretWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_DeleteApiSecretWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, *api.DeleteApiSecretParams, ...api.RequestEditorFn) (*api.DeleteApiSecretResponse, error)) *ClientWithResponsesInterface_DeleteApiSecretWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteApplicationWithResponse provides a mock function with given fields: ctx, applicationIdentifier, reqEditors
func (_m *ClientWithResponsesInterface) DeleteApplicationWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, reqEditors ...api.RequestEditorFn) (*api.DeleteApplicationResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

	return r0, r1
}

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

// DeleteApplicationWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) DeleteApplicationWithResponse(ctx interface{}, applicationIdentifier interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_DeleteApplicationWithResponse_Call {
	return &ClientWithResponsesInterface_DeleteApplicationWithResponse_Call{Call: _e.mock.On("DeleteApplicationWithResponse",
		append([]interface{}{ctx, applicationIdentifier}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_DeleteApplicationWithResponse_Call) Return(_a0 *api.DeleteApplicationResponse, _a1 error) *ClientWithResponsesInterface_DeleteApplicationWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_DeleteApplicationWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, ...api.RequestEditorFn) (*api.DeleteApplicationResponse, error)) *ClientWithResponsesInterface_DeleteApplicationWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetAllApplicationsWithResponse provides a mock function with given fields: ctx, params, reqEditors
func (_m *ClientWithResponsesInterface) GetAllApplicationsWithResponse(ctx context.Context, params *api.GetAllApplicationsParams, reqEditors ...api.RequestEditorFn) (*api.GetAllApplicationsResponse, 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...)

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

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

	return r0, r1
}

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

// GetAllApplicationsWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - params *api.GetAllApplicationsParams
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) GetAllApplicationsWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_GetAllApplicationsWithResponse_Call {
	return &ClientWithResponsesInterface_GetAllApplicationsWithResponse_Call{Call: _e.mock.On("GetAllApplicationsWithResponse",
		append([]interface{}{ctx, params}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_GetAllApplicationsWithResponse_Call) Return(_a0 *api.GetAllApplicationsResponse, _a1 error) *ClientWithResponsesInterface_GetAllApplicationsWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_GetAllApplicationsWithResponse_Call) RunAndReturn(run func(context.Context, *api.GetAllApplicationsParams, ...api.RequestEditorFn) (*api.GetAllApplicationsResponse, error)) *ClientWithResponsesInterface_GetAllApplicationsWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetApiSecretsWithResponse provides a mock function with given fields: ctx, applicationIdentifier, reqEditors
func (_m *ClientWithResponsesInterface) GetApiSecretsWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, reqEditors ...api.RequestEditorFn) (*api.GetApiSecretsResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

	return r0, r1
}

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

// GetApiSecretsWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) GetApiSecretsWithResponse(ctx interface{}, applicationIdentifier interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_GetApiSecretsWithResponse_Call {
	return &ClientWithResponsesInterface_GetApiSecretsWithResponse_Call{Call: _e.mock.On("GetApiSecretsWithResponse",
		append([]interface{}{ctx, applicationIdentifier}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_GetApiSecretsWithResponse_Call) Return(_a0 *api.GetApiSecretsResponse, _a1 error) *ClientWithResponsesInterface_GetApiSecretsWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_GetApiSecretsWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, ...api.RequestEditorFn) (*api.GetApiSecretsResponse, error)) *ClientWithResponsesInterface_GetApiSecretsWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// GetApplicationWithResponse provides a mock function with given fields: ctx, applicationIdentifier, params, reqEditors
func (_m *ClientWithResponsesInterface) GetApplicationWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, params *api.GetApplicationParams, reqEditors ...api.RequestEditorFn) (*api.GetApplicationResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, params)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID, *api.GetApplicationParams, ...api.RequestEditorFn) error); ok {
		r1 = rf(ctx, applicationIdentifier, params, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetApplicationWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - params *api.GetApplicationParams
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) GetApplicationWithResponse(ctx interface{}, applicationIdentifier interface{}, params interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_GetApplicationWithResponse_Call {
	return &ClientWithResponsesInterface_GetApplicationWithResponse_Call{Call: _e.mock.On("GetApplicationWithResponse",
		append([]interface{}{ctx, applicationIdentifier, params}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_GetApplicationWithResponse_Call) Return(_a0 *api.GetApplicationResponse, _a1 error) *ClientWithResponsesInterface_GetApplicationWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_GetApplicationWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, *api.GetApplicationParams, ...api.RequestEditorFn) (*api.GetApplicationResponse, error)) *ClientWithResponsesInterface_GetApplicationWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// PatchApplicationWithBodyWithResponse provides a mock function with given fields: ctx, applicationIdentifier, params, contentType, body, reqEditors
func (_m *ClientWithResponsesInterface) PatchApplicationWithBodyWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, params *api.PatchApplicationParams, contentType string, body io.Reader, reqEditors ...api.RequestEditorFn) (*api.PatchApplicationResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, params, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

	return r0, r1
}

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

// PatchApplicationWithBodyWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - params *api.PatchApplicationParams
//   - contentType string
//   - body io.Reader
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) PatchApplicationWithBodyWithResponse(ctx interface{}, applicationIdentifier interface{}, params interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_PatchApplicationWithBodyWithResponse_Call {
	return &ClientWithResponsesInterface_PatchApplicationWithBodyWithResponse_Call{Call: _e.mock.On("PatchApplicationWithBodyWithResponse",
		append([]interface{}{ctx, applicationIdentifier, params, contentType, body}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_PatchApplicationWithBodyWithResponse_Call) Return(_a0 *api.PatchApplicationResponse, _a1 error) *ClientWithResponsesInterface_PatchApplicationWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_PatchApplicationWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, *api.PatchApplicationParams, string, io.Reader, ...api.RequestEditorFn) (*api.PatchApplicationResponse, error)) *ClientWithResponsesInterface_PatchApplicationWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// PatchApplicationWithResponse provides a mock function with given fields: ctx, applicationIdentifier, params, body, reqEditors
func (_m *ClientWithResponsesInterface) PatchApplicationWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, params *api.PatchApplicationParams, body api.ApplicationPatch, reqEditors ...api.RequestEditorFn) (*api.PatchApplicationResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, params, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *api.PatchApplicationResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, *api.PatchApplicationParams, api.ApplicationPatch, ...api.RequestEditorFn) (*api.PatchApplicationResponse, error)); ok {
		return rf(ctx, applicationIdentifier, params, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, *api.PatchApplicationParams, api.ApplicationPatch, ...api.RequestEditorFn) *api.PatchApplicationResponse); ok {
		r0 = rf(ctx, applicationIdentifier, params, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*api.PatchApplicationResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID, *api.PatchApplicationParams, api.ApplicationPatch, ...api.RequestEditorFn) error); ok {
		r1 = rf(ctx, applicationIdentifier, params, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// PatchApplicationWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - params *api.PatchApplicationParams
//   - body api.ApplicationPatch
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) PatchApplicationWithResponse(ctx interface{}, applicationIdentifier interface{}, params interface{}, body interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_PatchApplicationWithResponse_Call {
	return &ClientWithResponsesInterface_PatchApplicationWithResponse_Call{Call: _e.mock.On("PatchApplicationWithResponse",
		append([]interface{}{ctx, applicationIdentifier, params, body}, reqEditors...)...)}
}

func (_c *ClientWithResponsesInterface_PatchApplicationWithResponse_Call) Run(run func(ctx context.Context, applicationIdentifier uuid.UUID, params *api.PatchApplicationParams, body api.ApplicationPatch, reqEditors ...api.RequestEditorFn)) *ClientWithResponsesInterface_PatchApplicationWithResponse_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]api.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(api.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(uuid.UUID), args[2].(*api.PatchApplicationParams), args[3].(api.ApplicationPatch), variadicArgs...)
	})
	return _c
}

func (_c *ClientWithResponsesInterface_PatchApplicationWithResponse_Call) Return(_a0 *api.PatchApplicationResponse, _a1 error) *ClientWithResponsesInterface_PatchApplicationWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_PatchApplicationWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, *api.PatchApplicationParams, api.ApplicationPatch, ...api.RequestEditorFn) (*api.PatchApplicationResponse, error)) *ClientWithResponsesInterface_PatchApplicationWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApplicationWithBodyWithResponse provides a mock function with given fields: ctx, applicationIdentifier, params, contentType, body, reqEditors
func (_m *ClientWithResponsesInterface) UpdateApplicationWithBodyWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, params *api.UpdateApplicationParams, contentType string, body io.Reader, reqEditors ...api.RequestEditorFn) (*api.UpdateApplicationResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, params, contentType, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

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

	return r0, r1
}

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

// UpdateApplicationWithBodyWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - params *api.UpdateApplicationParams
//   - contentType string
//   - body io.Reader
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) UpdateApplicationWithBodyWithResponse(ctx interface{}, applicationIdentifier interface{}, params interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_UpdateApplicationWithBodyWithResponse_Call {
	return &ClientWithResponsesInterface_UpdateApplicationWithBodyWithResponse_Call{Call: _e.mock.On("UpdateApplicationWithBodyWithResponse",
		append([]interface{}{ctx, applicationIdentifier, params, contentType, body}, reqEditors...)...)}
}

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

func (_c *ClientWithResponsesInterface_UpdateApplicationWithBodyWithResponse_Call) Return(_a0 *api.UpdateApplicationResponse, _a1 error) *ClientWithResponsesInterface_UpdateApplicationWithBodyWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_UpdateApplicationWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, *api.UpdateApplicationParams, string, io.Reader, ...api.RequestEditorFn) (*api.UpdateApplicationResponse, error)) *ClientWithResponsesInterface_UpdateApplicationWithBodyWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateApplicationWithResponse provides a mock function with given fields: ctx, applicationIdentifier, params, body, reqEditors
func (_m *ClientWithResponsesInterface) UpdateApplicationWithResponse(ctx context.Context, applicationIdentifier uuid.UUID, params *api.UpdateApplicationParams, body api.Application, reqEditors ...api.RequestEditorFn) (*api.UpdateApplicationResponse, error) {
	_va := make([]interface{}, len(reqEditors))
	for _i := range reqEditors {
		_va[_i] = reqEditors[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, applicationIdentifier, params, body)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *api.UpdateApplicationResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, *api.UpdateApplicationParams, api.Application, ...api.RequestEditorFn) (*api.UpdateApplicationResponse, error)); ok {
		return rf(ctx, applicationIdentifier, params, body, reqEditors...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, *api.UpdateApplicationParams, api.Application, ...api.RequestEditorFn) *api.UpdateApplicationResponse); ok {
		r0 = rf(ctx, applicationIdentifier, params, body, reqEditors...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*api.UpdateApplicationResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, uuid.UUID, *api.UpdateApplicationParams, api.Application, ...api.RequestEditorFn) error); ok {
		r1 = rf(ctx, applicationIdentifier, params, body, reqEditors...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateApplicationWithResponse is a helper method to define mock.On call
//   - ctx context.Context
//   - applicationIdentifier uuid.UUID
//   - params *api.UpdateApplicationParams
//   - body api.Application
//   - reqEditors ...api.RequestEditorFn
func (_e *ClientWithResponsesInterface_Expecter) UpdateApplicationWithResponse(ctx interface{}, applicationIdentifier interface{}, params interface{}, body interface{}, reqEditors ...interface{}) *ClientWithResponsesInterface_UpdateApplicationWithResponse_Call {
	return &ClientWithResponsesInterface_UpdateApplicationWithResponse_Call{Call: _e.mock.On("UpdateApplicationWithResponse",
		append([]interface{}{ctx, applicationIdentifier, params, body}, reqEditors...)...)}
}

func (_c *ClientWithResponsesInterface_UpdateApplicationWithResponse_Call) Run(run func(ctx context.Context, applicationIdentifier uuid.UUID, params *api.UpdateApplicationParams, body api.Application, reqEditors ...api.RequestEditorFn)) *ClientWithResponsesInterface_UpdateApplicationWithResponse_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]api.RequestEditorFn, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(api.RequestEditorFn)
			}
		}
		run(args[0].(context.Context), args[1].(uuid.UUID), args[2].(*api.UpdateApplicationParams), args[3].(api.Application), variadicArgs...)
	})
	return _c
}

func (_c *ClientWithResponsesInterface_UpdateApplicationWithResponse_Call) Return(_a0 *api.UpdateApplicationResponse, _a1 error) *ClientWithResponsesInterface_UpdateApplicationWithResponse_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *ClientWithResponsesInterface_UpdateApplicationWithResponse_Call) RunAndReturn(run func(context.Context, uuid.UUID, *api.UpdateApplicationParams, api.Application, ...api.RequestEditorFn) (*api.UpdateApplicationResponse, error)) *ClientWithResponsesInterface_UpdateApplicationWithResponse_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}