zitadel/pkg/management/api/grpc/mock/management.proto.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/caos/zitadel/pkg/management/api/grpc (interfaces: ManagementServiceClient)

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

import (
	context "context"
	grpc "github.com/caos/zitadel/pkg/management/api/grpc"
	gomock "github.com/golang/mock/gomock"
	grpc0 "google.golang.org/grpc"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	reflect "reflect"
)

// MockManagementServiceClient is a mock of ManagementServiceClient interface
type MockManagementServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockManagementServiceClientMockRecorder
}

// MockManagementServiceClientMockRecorder is the mock recorder for MockManagementServiceClient
type MockManagementServiceClientMockRecorder struct {
	mock *MockManagementServiceClient
}

// NewMockManagementServiceClient creates a new mock instance
func NewMockManagementServiceClient(ctrl *gomock.Controller) *MockManagementServiceClient {
	mock := &MockManagementServiceClient{ctrl: ctrl}
	mock.recorder = &MockManagementServiceClientMockRecorder{mock}
	return mock
}

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

// AddMyOrgDomain mocks base method
func (m *MockManagementServiceClient) AddMyOrgDomain(arg0 context.Context, arg1 *grpc.AddOrgDomainRequest, arg2 ...grpc0.CallOption) (*grpc.OrgDomain, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddMyOrgDomain", varargs...)
	ret0, _ := ret[0].(*grpc.OrgDomain)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddMyOrgMember mocks base method
func (m *MockManagementServiceClient) AddMyOrgMember(arg0 context.Context, arg1 *grpc.AddOrgMemberRequest, arg2 ...grpc0.CallOption) (*grpc.OrgMember, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddMyOrgMember", varargs...)
	ret0, _ := ret[0].(*grpc.OrgMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddProjectGrantMember mocks base method
func (m *MockManagementServiceClient) AddProjectGrantMember(arg0 context.Context, arg1 *grpc.ProjectGrantMemberAdd, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantMember, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddProjectGrantMember", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrantMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddProjectMember mocks base method
func (m *MockManagementServiceClient) AddProjectMember(arg0 context.Context, arg1 *grpc.ProjectMemberAdd, arg2 ...grpc0.CallOption) (*grpc.ProjectMember, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddProjectMember", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddProjectRole mocks base method
func (m *MockManagementServiceClient) AddProjectRole(arg0 context.Context, arg1 *grpc.ProjectRoleAdd, arg2 ...grpc0.CallOption) (*grpc.ProjectRole, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddProjectRole", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ApplicationByID mocks base method
func (m *MockManagementServiceClient) ApplicationByID(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.Application, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ApplicationByID", varargs...)
	ret0, _ := ret[0].(*grpc.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ApplicationChanges mocks base method
func (m *MockManagementServiceClient) ApplicationChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ApplicationChanges", varargs...)
	ret0, _ := ret[0].(*grpc.Changes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BulkAddProjectRole mocks base method
func (m *MockManagementServiceClient) BulkAddProjectRole(arg0 context.Context, arg1 *grpc.ProjectRoleAddBulk, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BulkAddProjectRole", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BulkCreateUserGrant mocks base method
func (m *MockManagementServiceClient) BulkCreateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantCreateBulk, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BulkCreateUserGrant", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BulkRemoveUserGrant mocks base method
func (m *MockManagementServiceClient) BulkRemoveUserGrant(arg0 context.Context, arg1 *grpc.UserGrantRemoveBulk, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BulkRemoveUserGrant", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BulkUpdateUserGrant mocks base method
func (m *MockManagementServiceClient) BulkUpdateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantUpdateBulk, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BulkUpdateUserGrant", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeMyOrgMember mocks base method
func (m *MockManagementServiceClient) ChangeMyOrgMember(arg0 context.Context, arg1 *grpc.ChangeOrgMemberRequest, arg2 ...grpc0.CallOption) (*grpc.OrgMember, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeMyOrgMember", varargs...)
	ret0, _ := ret[0].(*grpc.OrgMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeProjectGrantMember mocks base method
func (m *MockManagementServiceClient) ChangeProjectGrantMember(arg0 context.Context, arg1 *grpc.ProjectGrantMemberChange, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantMember, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeProjectGrantMember", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrantMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeProjectMember mocks base method
func (m *MockManagementServiceClient) ChangeProjectMember(arg0 context.Context, arg1 *grpc.ProjectMemberChange, arg2 ...grpc0.CallOption) (*grpc.ProjectMember, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeProjectMember", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectMember)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeProjectRole mocks base method
func (m *MockManagementServiceClient) ChangeProjectRole(arg0 context.Context, arg1 *grpc.ProjectRoleChange, arg2 ...grpc0.CallOption) (*grpc.ProjectRole, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeProjectRole", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeUserEmail mocks base method
func (m *MockManagementServiceClient) ChangeUserEmail(arg0 context.Context, arg1 *grpc.UpdateUserEmailRequest, arg2 ...grpc0.CallOption) (*grpc.UserEmail, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeUserEmail", varargs...)
	ret0, _ := ret[0].(*grpc.UserEmail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ChangeUserPhone mocks base method
func (m *MockManagementServiceClient) ChangeUserPhone(arg0 context.Context, arg1 *grpc.UpdateUserPhoneRequest, arg2 ...grpc0.CallOption) (*grpc.UserPhone, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ChangeUserPhone", varargs...)
	ret0, _ := ret[0].(*grpc.UserPhone)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateOIDCApplication mocks base method
func (m *MockManagementServiceClient) CreateOIDCApplication(arg0 context.Context, arg1 *grpc.OIDCApplicationCreate, arg2 ...grpc0.CallOption) (*grpc.Application, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateOIDCApplication", varargs...)
	ret0, _ := ret[0].(*grpc.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePasswordAgePolicy mocks base method
func (m *MockManagementServiceClient) CreatePasswordAgePolicy(arg0 context.Context, arg1 *grpc.PasswordAgePolicyCreate, arg2 ...grpc0.CallOption) (*grpc.PasswordAgePolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePasswordAgePolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordAgePolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePasswordComplexityPolicy mocks base method
func (m *MockManagementServiceClient) CreatePasswordComplexityPolicy(arg0 context.Context, arg1 *grpc.PasswordComplexityPolicyCreate, arg2 ...grpc0.CallOption) (*grpc.PasswordComplexityPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePasswordComplexityPolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordComplexityPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreatePasswordLockoutPolicy mocks base method
func (m *MockManagementServiceClient) CreatePasswordLockoutPolicy(arg0 context.Context, arg1 *grpc.PasswordLockoutPolicyCreate, arg2 ...grpc0.CallOption) (*grpc.PasswordLockoutPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePasswordLockoutPolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordLockoutPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProject mocks base method
func (m *MockManagementServiceClient) CreateProject(arg0 context.Context, arg1 *grpc.ProjectCreateRequest, arg2 ...grpc0.CallOption) (*grpc.Project, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateProject", varargs...)
	ret0, _ := ret[0].(*grpc.Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProjectGrant mocks base method
func (m *MockManagementServiceClient) CreateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantCreate, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateProjectGrant", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProjectGrantUserGrant mocks base method
func (m *MockManagementServiceClient) CreateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantCreate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateProjectGrantUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateProjectUserGrant mocks base method
func (m *MockManagementServiceClient) CreateProjectUserGrant(arg0 context.Context, arg1 *grpc.UserGrantCreate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateProjectUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateUser mocks base method
func (m *MockManagementServiceClient) CreateUser(arg0 context.Context, arg1 *grpc.CreateUserRequest, arg2 ...grpc0.CallOption) (*grpc.User, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateUser", varargs...)
	ret0, _ := ret[0].(*grpc.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateUserGrant mocks base method
func (m *MockManagementServiceClient) CreateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantCreate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateApplication mocks base method
func (m *MockManagementServiceClient) DeactivateApplication(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.Application, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateApplication", varargs...)
	ret0, _ := ret[0].(*grpc.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateOrg mocks base method
func (m *MockManagementServiceClient) DeactivateOrg(arg0 context.Context, arg1 *grpc.OrgID, arg2 ...grpc0.CallOption) (*grpc.Org, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateOrg", varargs...)
	ret0, _ := ret[0].(*grpc.Org)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateProject mocks base method
func (m *MockManagementServiceClient) DeactivateProject(arg0 context.Context, arg1 *grpc.ProjectID, arg2 ...grpc0.CallOption) (*grpc.Project, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateProject", varargs...)
	ret0, _ := ret[0].(*grpc.Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateProjectGrant mocks base method
func (m *MockManagementServiceClient) DeactivateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateProjectGrant", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateProjectGrantUserGrant mocks base method
func (m *MockManagementServiceClient) DeactivateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateProjectGrantUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateProjectUserGrant mocks base method
func (m *MockManagementServiceClient) DeactivateProjectUserGrant(arg0 context.Context, arg1 *grpc.ProjectUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateProjectUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateUser mocks base method
func (m *MockManagementServiceClient) DeactivateUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateUser", varargs...)
	ret0, _ := ret[0].(*grpc.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeactivateUserGrant mocks base method
func (m *MockManagementServiceClient) DeactivateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeactivateUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePasswordAgePolicy mocks base method
func (m *MockManagementServiceClient) DeletePasswordAgePolicy(arg0 context.Context, arg1 *grpc.PasswordAgePolicyID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePasswordAgePolicy", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePasswordComplexityPolicy mocks base method
func (m *MockManagementServiceClient) DeletePasswordComplexityPolicy(arg0 context.Context, arg1 *grpc.PasswordComplexityPolicyID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePasswordComplexityPolicy", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePasswordLockoutPolicy mocks base method
func (m *MockManagementServiceClient) DeletePasswordLockoutPolicy(arg0 context.Context, arg1 *grpc.PasswordLockoutPolicyID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePasswordLockoutPolicy", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteUser mocks base method
func (m *MockManagementServiceClient) DeleteUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteUser", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetGrantedProjectByID mocks base method
func (m *MockManagementServiceClient) GetGrantedProjectByID(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantView, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetGrantedProjectByID", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrantView)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetIam mocks base method
func (m *MockManagementServiceClient) GetIam(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.Iam, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetIam", varargs...)
	ret0, _ := ret[0].(*grpc.Iam)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMyOrgIamPolicy mocks base method
func (m *MockManagementServiceClient) GetMyOrgIamPolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.OrgIamPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMyOrgIamPolicy", varargs...)
	ret0, _ := ret[0].(*grpc.OrgIamPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOrgByDomainGlobal mocks base method
func (m *MockManagementServiceClient) GetOrgByDomainGlobal(arg0 context.Context, arg1 *grpc.OrgDomain, arg2 ...grpc0.CallOption) (*grpc.Org, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrgByDomainGlobal", varargs...)
	ret0, _ := ret[0].(*grpc.Org)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOrgByID mocks base method
func (m *MockManagementServiceClient) GetOrgByID(arg0 context.Context, arg1 *grpc.OrgID, arg2 ...grpc0.CallOption) (*grpc.Org, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrgByID", varargs...)
	ret0, _ := ret[0].(*grpc.Org)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetOrgMemberRoles mocks base method
func (m *MockManagementServiceClient) GetOrgMemberRoles(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.OrgMemberRoles, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetOrgMemberRoles", varargs...)
	ret0, _ := ret[0].(*grpc.OrgMemberRoles)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPasswordAgePolicy mocks base method
func (m *MockManagementServiceClient) GetPasswordAgePolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.PasswordAgePolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPasswordAgePolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordAgePolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPasswordComplexityPolicy mocks base method
func (m *MockManagementServiceClient) GetPasswordComplexityPolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.PasswordComplexityPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPasswordComplexityPolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordComplexityPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPasswordLockoutPolicy mocks base method
func (m *MockManagementServiceClient) GetPasswordLockoutPolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.PasswordLockoutPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetPasswordLockoutPolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordLockoutPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProjectGrantMemberRoles mocks base method
func (m *MockManagementServiceClient) GetProjectGrantMemberRoles(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantMemberRoles, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectGrantMemberRoles", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrantMemberRoles)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetProjectMemberRoles mocks base method
func (m *MockManagementServiceClient) GetProjectMemberRoles(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*grpc.ProjectMemberRoles, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetProjectMemberRoles", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectMemberRoles)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserAddress mocks base method
func (m *MockManagementServiceClient) GetUserAddress(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserAddressView, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserAddress", varargs...)
	ret0, _ := ret[0].(*grpc.UserAddressView)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserByEmailGlobal mocks base method
func (m *MockManagementServiceClient) GetUserByEmailGlobal(arg0 context.Context, arg1 *grpc.UserEmailID, arg2 ...grpc0.CallOption) (*grpc.UserView, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserByEmailGlobal", varargs...)
	ret0, _ := ret[0].(*grpc.UserView)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserByID mocks base method
func (m *MockManagementServiceClient) GetUserByID(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserView, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserByID", varargs...)
	ret0, _ := ret[0].(*grpc.UserView)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserEmail mocks base method
func (m *MockManagementServiceClient) GetUserEmail(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserEmailView, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserEmail", varargs...)
	ret0, _ := ret[0].(*grpc.UserEmailView)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserMfas mocks base method
func (m *MockManagementServiceClient) GetUserMfas(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.MultiFactors, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserMfas", varargs...)
	ret0, _ := ret[0].(*grpc.MultiFactors)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserPhone mocks base method
func (m *MockManagementServiceClient) GetUserPhone(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserPhoneView, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserPhone", varargs...)
	ret0, _ := ret[0].(*grpc.UserPhoneView)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetUserProfile mocks base method
func (m *MockManagementServiceClient) GetUserProfile(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserProfileView, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetUserProfile", varargs...)
	ret0, _ := ret[0].(*grpc.UserProfileView)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Healthz mocks base method
func (m *MockManagementServiceClient) Healthz(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Healthz", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IsUserUnique mocks base method
func (m *MockManagementServiceClient) IsUserUnique(arg0 context.Context, arg1 *grpc.UniqueUserRequest, arg2 ...grpc0.CallOption) (*grpc.UniqueUserResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "IsUserUnique", varargs...)
	ret0, _ := ret[0].(*grpc.UniqueUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// LockUser mocks base method
func (m *MockManagementServiceClient) LockUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LockUser", varargs...)
	ret0, _ := ret[0].(*grpc.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// OrgChanges mocks base method
func (m *MockManagementServiceClient) OrgChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "OrgChanges", varargs...)
	ret0, _ := ret[0].(*grpc.Changes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProjectByID mocks base method
func (m *MockManagementServiceClient) ProjectByID(arg0 context.Context, arg1 *grpc.ProjectID, arg2 ...grpc0.CallOption) (*grpc.Project, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProjectByID", varargs...)
	ret0, _ := ret[0].(*grpc.Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProjectChanges mocks base method
func (m *MockManagementServiceClient) ProjectChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProjectChanges", varargs...)
	ret0, _ := ret[0].(*grpc.Changes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProjectGrantByID mocks base method
func (m *MockManagementServiceClient) ProjectGrantByID(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProjectGrantByID", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProjectGrantUserGrantByID mocks base method
func (m *MockManagementServiceClient) ProjectGrantUserGrantByID(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProjectGrantUserGrantByID", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ProjectUserGrantByID mocks base method
func (m *MockManagementServiceClient) ProjectUserGrantByID(arg0 context.Context, arg1 *grpc.ProjectUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ProjectUserGrantByID", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateApplication mocks base method
func (m *MockManagementServiceClient) ReactivateApplication(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.Application, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateApplication", varargs...)
	ret0, _ := ret[0].(*grpc.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateOrg mocks base method
func (m *MockManagementServiceClient) ReactivateOrg(arg0 context.Context, arg1 *grpc.OrgID, arg2 ...grpc0.CallOption) (*grpc.Org, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateOrg", varargs...)
	ret0, _ := ret[0].(*grpc.Org)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateProject mocks base method
func (m *MockManagementServiceClient) ReactivateProject(arg0 context.Context, arg1 *grpc.ProjectID, arg2 ...grpc0.CallOption) (*grpc.Project, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateProject", varargs...)
	ret0, _ := ret[0].(*grpc.Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateProjectGrant mocks base method
func (m *MockManagementServiceClient) ReactivateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateProjectGrant", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateProjectGrantUserGrant mocks base method
func (m *MockManagementServiceClient) ReactivateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateProjectGrantUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateProjectUserGrant mocks base method
func (m *MockManagementServiceClient) ReactivateProjectUserGrant(arg0 context.Context, arg1 *grpc.ProjectUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateProjectUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateUser mocks base method
func (m *MockManagementServiceClient) ReactivateUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateUser", varargs...)
	ret0, _ := ret[0].(*grpc.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReactivateUserGrant mocks base method
func (m *MockManagementServiceClient) ReactivateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReactivateUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Ready mocks base method
func (m *MockManagementServiceClient) Ready(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Ready", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegenerateOIDCClientSecret mocks base method
func (m *MockManagementServiceClient) RegenerateOIDCClientSecret(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.ClientSecret, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegenerateOIDCClientSecret", varargs...)
	ret0, _ := ret[0].(*grpc.ClientSecret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveApplication mocks base method
func (m *MockManagementServiceClient) RemoveApplication(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveApplication", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveMyOrgDomain mocks base method
func (m *MockManagementServiceClient) RemoveMyOrgDomain(arg0 context.Context, arg1 *grpc.RemoveOrgDomainRequest, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveMyOrgDomain", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveMyOrgMember mocks base method
func (m *MockManagementServiceClient) RemoveMyOrgMember(arg0 context.Context, arg1 *grpc.RemoveOrgMemberRequest, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveMyOrgMember", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveProjectGrant mocks base method
func (m *MockManagementServiceClient) RemoveProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveProjectGrant", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveProjectGrantMember mocks base method
func (m *MockManagementServiceClient) RemoveProjectGrantMember(arg0 context.Context, arg1 *grpc.ProjectGrantMemberRemove, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveProjectGrantMember", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveProjectMember mocks base method
func (m *MockManagementServiceClient) RemoveProjectMember(arg0 context.Context, arg1 *grpc.ProjectMemberRemove, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveProjectMember", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveProjectRole mocks base method
func (m *MockManagementServiceClient) RemoveProjectRole(arg0 context.Context, arg1 *grpc.ProjectRoleRemove, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveProjectRole", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveUserGrant mocks base method
func (m *MockManagementServiceClient) RemoveUserGrant(arg0 context.Context, arg1 *grpc.UserGrantID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveUserGrant", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResendEmailVerificationMail mocks base method
func (m *MockManagementServiceClient) ResendEmailVerificationMail(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResendEmailVerificationMail", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResendPhoneVerificationCode mocks base method
func (m *MockManagementServiceClient) ResendPhoneVerificationCode(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResendPhoneVerificationCode", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchApplications mocks base method
func (m *MockManagementServiceClient) SearchApplications(arg0 context.Context, arg1 *grpc.ApplicationSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ApplicationSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchApplications", varargs...)
	ret0, _ := ret[0].(*grpc.ApplicationSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchAuthGrant mocks base method
func (m *MockManagementServiceClient) SearchAuthGrant(arg0 context.Context, arg1 *grpc.AuthGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.AuthGrantSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchAuthGrant", varargs...)
	ret0, _ := ret[0].(*grpc.AuthGrantSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchGrantedProjects mocks base method
func (m *MockManagementServiceClient) SearchGrantedProjects(arg0 context.Context, arg1 *grpc.GrantedProjectSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchGrantedProjects", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrantSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchMyOrgDomains mocks base method
func (m *MockManagementServiceClient) SearchMyOrgDomains(arg0 context.Context, arg1 *grpc.OrgDomainSearchRequest, arg2 ...grpc0.CallOption) (*grpc.OrgDomainSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchMyOrgDomains", varargs...)
	ret0, _ := ret[0].(*grpc.OrgDomainSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchMyOrgMembers mocks base method
func (m *MockManagementServiceClient) SearchMyOrgMembers(arg0 context.Context, arg1 *grpc.OrgMemberSearchRequest, arg2 ...grpc0.CallOption) (*grpc.OrgMemberSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchMyOrgMembers", varargs...)
	ret0, _ := ret[0].(*grpc.OrgMemberSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchProjectGrantMembers mocks base method
func (m *MockManagementServiceClient) SearchProjectGrantMembers(arg0 context.Context, arg1 *grpc.ProjectGrantMemberSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantMemberSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchProjectGrantMembers", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrantMemberSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchProjectGrantUserGrants mocks base method
func (m *MockManagementServiceClient) SearchProjectGrantUserGrants(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserGrantSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchProjectGrantUserGrants", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrantSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchProjectGrants mocks base method
func (m *MockManagementServiceClient) SearchProjectGrants(arg0 context.Context, arg1 *grpc.ProjectGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchProjectGrants", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrantSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchProjectMembers mocks base method
func (m *MockManagementServiceClient) SearchProjectMembers(arg0 context.Context, arg1 *grpc.ProjectMemberSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectMemberSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchProjectMembers", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectMemberSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchProjectRoles mocks base method
func (m *MockManagementServiceClient) SearchProjectRoles(arg0 context.Context, arg1 *grpc.ProjectRoleSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectRoleSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchProjectRoles", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectRoleSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchProjectUserGrants mocks base method
func (m *MockManagementServiceClient) SearchProjectUserGrants(arg0 context.Context, arg1 *grpc.ProjectUserGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserGrantSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchProjectUserGrants", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrantSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchProjects mocks base method
func (m *MockManagementServiceClient) SearchProjects(arg0 context.Context, arg1 *grpc.ProjectSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchProjects", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchUserGrants mocks base method
func (m *MockManagementServiceClient) SearchUserGrants(arg0 context.Context, arg1 *grpc.UserGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserGrantSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchUserGrants", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrantSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchUsers mocks base method
func (m *MockManagementServiceClient) SearchUsers(arg0 context.Context, arg1 *grpc.UserSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserSearchResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SearchUsers", varargs...)
	ret0, _ := ret[0].(*grpc.UserSearchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SendSetPasswordNotification mocks base method
func (m *MockManagementServiceClient) SendSetPasswordNotification(arg0 context.Context, arg1 *grpc.SetPasswordNotificationRequest, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SendSetPasswordNotification", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetInitialPassword mocks base method
func (m *MockManagementServiceClient) SetInitialPassword(arg0 context.Context, arg1 *grpc.PasswordRequest, arg2 ...grpc0.CallOption) (*emptypb.Empty, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetInitialPassword", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnlockUser mocks base method
func (m *MockManagementServiceClient) UnlockUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UnlockUser", varargs...)
	ret0, _ := ret[0].(*grpc.User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateApplication mocks base method
func (m *MockManagementServiceClient) UpdateApplication(arg0 context.Context, arg1 *grpc.ApplicationUpdate, arg2 ...grpc0.CallOption) (*grpc.Application, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateApplication", varargs...)
	ret0, _ := ret[0].(*grpc.Application)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateApplicationOIDCConfig mocks base method
func (m *MockManagementServiceClient) UpdateApplicationOIDCConfig(arg0 context.Context, arg1 *grpc.OIDCConfigUpdate, arg2 ...grpc0.CallOption) (*grpc.OIDCConfig, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateApplicationOIDCConfig", varargs...)
	ret0, _ := ret[0].(*grpc.OIDCConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePasswordAgePolicy mocks base method
func (m *MockManagementServiceClient) UpdatePasswordAgePolicy(arg0 context.Context, arg1 *grpc.PasswordAgePolicyUpdate, arg2 ...grpc0.CallOption) (*grpc.PasswordAgePolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePasswordAgePolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordAgePolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePasswordComplexityPolicy mocks base method
func (m *MockManagementServiceClient) UpdatePasswordComplexityPolicy(arg0 context.Context, arg1 *grpc.PasswordComplexityPolicyUpdate, arg2 ...grpc0.CallOption) (*grpc.PasswordComplexityPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePasswordComplexityPolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordComplexityPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdatePasswordLockoutPolicy mocks base method
func (m *MockManagementServiceClient) UpdatePasswordLockoutPolicy(arg0 context.Context, arg1 *grpc.PasswordLockoutPolicyUpdate, arg2 ...grpc0.CallOption) (*grpc.PasswordLockoutPolicy, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePasswordLockoutPolicy", varargs...)
	ret0, _ := ret[0].(*grpc.PasswordLockoutPolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateProject mocks base method
func (m *MockManagementServiceClient) UpdateProject(arg0 context.Context, arg1 *grpc.ProjectUpdateRequest, arg2 ...grpc0.CallOption) (*grpc.Project, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateProject", varargs...)
	ret0, _ := ret[0].(*grpc.Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateProjectGrant mocks base method
func (m *MockManagementServiceClient) UpdateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateProjectGrant", varargs...)
	ret0, _ := ret[0].(*grpc.ProjectGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateProjectGrantUserGrant mocks base method
func (m *MockManagementServiceClient) UpdateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateProjectGrantUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateProjectUserGrant mocks base method
func (m *MockManagementServiceClient) UpdateProjectUserGrant(arg0 context.Context, arg1 *grpc.ProjectUserGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateProjectUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateUserAddress mocks base method
func (m *MockManagementServiceClient) UpdateUserAddress(arg0 context.Context, arg1 *grpc.UpdateUserAddressRequest, arg2 ...grpc0.CallOption) (*grpc.UserAddress, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserAddress", varargs...)
	ret0, _ := ret[0].(*grpc.UserAddress)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateUserGrant mocks base method
func (m *MockManagementServiceClient) UpdateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserGrant", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateUserProfile mocks base method
func (m *MockManagementServiceClient) UpdateUserProfile(arg0 context.Context, arg1 *grpc.UpdateUserProfileRequest, arg2 ...grpc0.CallOption) (*grpc.UserProfile, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateUserProfile", varargs...)
	ret0, _ := ret[0].(*grpc.UserProfile)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UserChanges mocks base method
func (m *MockManagementServiceClient) UserChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UserChanges", varargs...)
	ret0, _ := ret[0].(*grpc.Changes)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UserGrantByID mocks base method
func (m *MockManagementServiceClient) UserGrantByID(arg0 context.Context, arg1 *grpc.UserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UserGrantByID", varargs...)
	ret0, _ := ret[0].(*grpc.UserGrant)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Validate mocks base method
func (m *MockManagementServiceClient) Validate(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc0.CallOption) (*structpb.Struct, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Validate", varargs...)
	ret0, _ := ret[0].(*structpb.Struct)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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