mock_auth_client.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/treeverse/lakefs/pkg/auth (interfaces: ClientWithResponsesInterface)

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

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

	gomock "github.com/golang/mock/gomock"
	auth "github.com/treeverse/lakefs/pkg/auth"
)

// MockClientWithResponsesInterface is a mock of ClientWithResponsesInterface interface.
type MockClientWithResponsesInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClientWithResponsesInterfaceMockRecorder
}

// MockClientWithResponsesInterfaceMockRecorder is the mock recorder for MockClientWithResponsesInterface.
type MockClientWithResponsesInterfaceMockRecorder struct {
	mock *MockClientWithResponsesInterface
}

// NewMockClientWithResponsesInterface creates a new mock instance.
func NewMockClientWithResponsesInterface(ctrl *gomock.Controller) *MockClientWithResponsesInterface {
	mock := &MockClientWithResponsesInterface{ctrl: ctrl}
	mock.recorder = &MockClientWithResponsesInterfaceMockRecorder{mock}
	return mock
}

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

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

// AddGroupMembershipWithResponse indicates an expected call of AddGroupMembershipWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) AddGroupMembershipWithResponse(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, "AddGroupMembershipWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).AddGroupMembershipWithResponse), varargs...)
}

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

// AttachPolicyToGroupWithResponse indicates an expected call of AttachPolicyToGroupWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) AttachPolicyToGroupWithResponse(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, "AttachPolicyToGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).AttachPolicyToGroupWithResponse), varargs...)
}

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

// AttachPolicyToUserWithResponse indicates an expected call of AttachPolicyToUserWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) AttachPolicyToUserWithResponse(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, "AttachPolicyToUserWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).AttachPolicyToUserWithResponse), varargs...)
}

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

// ClaimTokenIdWithBodyWithResponse indicates an expected call of ClaimTokenIdWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ClaimTokenIdWithBodyWithResponse(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, "ClaimTokenIdWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ClaimTokenIdWithBodyWithResponse), varargs...)
}

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

// ClaimTokenIdWithResponse indicates an expected call of ClaimTokenIdWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ClaimTokenIdWithResponse(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, "ClaimTokenIdWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ClaimTokenIdWithResponse), varargs...)
}

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

// CreateCredentialsWithResponse indicates an expected call of CreateCredentialsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateCredentialsWithResponse(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, "CreateCredentialsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateCredentialsWithResponse), varargs...)
}

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

// CreateGroupWithBodyWithResponse indicates an expected call of CreateGroupWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateGroupWithBodyWithResponse(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, "CreateGroupWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateGroupWithBodyWithResponse), varargs...)
}

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

// CreateGroupWithResponse indicates an expected call of CreateGroupWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateGroupWithResponse(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, "CreateGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateGroupWithResponse), varargs...)
}

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

// CreatePolicyWithBodyWithResponse indicates an expected call of CreatePolicyWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreatePolicyWithBodyWithResponse(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, "CreatePolicyWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreatePolicyWithBodyWithResponse), varargs...)
}

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

// CreatePolicyWithResponse indicates an expected call of CreatePolicyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreatePolicyWithResponse(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, "CreatePolicyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreatePolicyWithResponse), varargs...)
}

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

// CreateUserWithBodyWithResponse indicates an expected call of CreateUserWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateUserWithBodyWithResponse(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, "CreateUserWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateUserWithBodyWithResponse), varargs...)
}

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

// CreateUserWithResponse indicates an expected call of CreateUserWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateUserWithResponse(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, "CreateUserWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateUserWithResponse), varargs...)
}

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

// DeleteCredentialsWithResponse indicates an expected call of DeleteCredentialsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteCredentialsWithResponse(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, "DeleteCredentialsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteCredentialsWithResponse), varargs...)
}

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

// DeleteGroupMembershipWithResponse indicates an expected call of DeleteGroupMembershipWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteGroupMembershipWithResponse(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, "DeleteGroupMembershipWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteGroupMembershipWithResponse), varargs...)
}

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

// DeleteGroupWithResponse indicates an expected call of DeleteGroupWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteGroupWithResponse(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, "DeleteGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteGroupWithResponse), varargs...)
}

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

// DeletePolicyWithResponse indicates an expected call of DeletePolicyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeletePolicyWithResponse(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, "DeletePolicyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeletePolicyWithResponse), varargs...)
}

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

// DeleteUserWithResponse indicates an expected call of DeleteUserWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteUserWithResponse(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, "DeleteUserWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteUserWithResponse), varargs...)
}

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

// DetachPolicyFromGroupWithResponse indicates an expected call of DetachPolicyFromGroupWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DetachPolicyFromGroupWithResponse(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, "DetachPolicyFromGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DetachPolicyFromGroupWithResponse), varargs...)
}

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

// DetachPolicyFromUserWithResponse indicates an expected call of DetachPolicyFromUserWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DetachPolicyFromUserWithResponse(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, "DetachPolicyFromUserWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DetachPolicyFromUserWithResponse), varargs...)
}

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

// GetCredentialsForUserWithResponse indicates an expected call of GetCredentialsForUserWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCredentialsForUserWithResponse(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, "GetCredentialsForUserWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCredentialsForUserWithResponse), varargs...)
}

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

// GetCredentialsWithResponse indicates an expected call of GetCredentialsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCredentialsWithResponse(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, "GetCredentialsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCredentialsWithResponse), varargs...)
}

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

// GetGroupWithResponse indicates an expected call of GetGroupWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetGroupWithResponse(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, "GetGroupWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetGroupWithResponse), varargs...)
}

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

// GetPolicyWithResponse indicates an expected call of GetPolicyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetPolicyWithResponse(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, "GetPolicyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetPolicyWithResponse), varargs...)
}

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

// GetUserWithResponse indicates an expected call of GetUserWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetUserWithResponse(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, "GetUserWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetUserWithResponse), varargs...)
}

// GetVersionWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetVersionWithResponse(arg0 context.Context, arg1 ...auth.RequestEditorFn) (*auth.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].(*auth.GetVersionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVersionWithResponse indicates an expected call of GetVersionWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) 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((*MockClientWithResponsesInterface)(nil).GetVersionWithResponse), varargs...)
}

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

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

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

// ListGroupMembersWithResponse indicates an expected call of ListGroupMembersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListGroupMembersWithResponse(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, "ListGroupMembersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListGroupMembersWithResponse), varargs...)
}

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

// ListGroupPoliciesWithResponse indicates an expected call of ListGroupPoliciesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListGroupPoliciesWithResponse(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, "ListGroupPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListGroupPoliciesWithResponse), varargs...)
}

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

// ListGroupsWithResponse indicates an expected call of ListGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListGroupsWithResponse(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, "ListGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListGroupsWithResponse), varargs...)
}

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

// ListPoliciesWithResponse indicates an expected call of ListPoliciesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListPoliciesWithResponse(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, "ListPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListPoliciesWithResponse), varargs...)
}

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

// ListUserCredentialsWithResponse indicates an expected call of ListUserCredentialsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListUserCredentialsWithResponse(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, "ListUserCredentialsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListUserCredentialsWithResponse), varargs...)
}

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

// ListUserGroupsWithResponse indicates an expected call of ListUserGroupsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListUserGroupsWithResponse(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, "ListUserGroupsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListUserGroupsWithResponse), varargs...)
}

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

// ListUserPoliciesWithResponse indicates an expected call of ListUserPoliciesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListUserPoliciesWithResponse(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, "ListUserPoliciesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListUserPoliciesWithResponse), varargs...)
}

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

// ListUsersWithResponse indicates an expected call of ListUsersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) ListUsersWithResponse(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, "ListUsersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).ListUsersWithResponse), varargs...)
}

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

// UpdatePasswordWithBodyWithResponse indicates an expected call of UpdatePasswordWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) UpdatePasswordWithBodyWithResponse(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, "UpdatePasswordWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).UpdatePasswordWithBodyWithResponse), varargs...)
}

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

// UpdatePasswordWithResponse indicates an expected call of UpdatePasswordWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) UpdatePasswordWithResponse(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, "UpdatePasswordWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).UpdatePasswordWithResponse), varargs...)
}

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

// UpdatePolicyWithBodyWithResponse indicates an expected call of UpdatePolicyWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) UpdatePolicyWithBodyWithResponse(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, "UpdatePolicyWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).UpdatePolicyWithBodyWithResponse), varargs...)
}

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

// UpdatePolicyWithResponse indicates an expected call of UpdatePolicyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) UpdatePolicyWithResponse(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, "UpdatePolicyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).UpdatePolicyWithResponse), varargs...)
}