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

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

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

import (
	context "context"
	management "github.com/caos/zitadel/pkg/grpc/management"
	gomock "github.com/golang/mock/gomock"
	grpc "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
}

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

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

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

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

// AddMyOrgDomain mocks base method
func (m *MockManagementServiceClient) AddMyOrgDomain(arg0 context.Context, arg1 *management.AddOrgDomainRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.AddOrgMemberRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantMemberAdd, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectMemberAdd, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectRoleAdd, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ApplicationID, arg2 ...grpc.CallOption) (*management.ApplicationView, 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].(*management.ApplicationView)
	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 *management.ChangeRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectRoleAddBulk, arg2 ...grpc.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...)
}

// BulkRemoveUserGrant mocks base method
func (m *MockManagementServiceClient) BulkRemoveUserGrant(arg0 context.Context, arg1 *management.UserGrantRemoveBulk, arg2 ...grpc.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...)
}

// ChangeMyOrgMember mocks base method
func (m *MockManagementServiceClient) ChangeMyOrgMember(arg0 context.Context, arg1 *management.ChangeOrgMemberRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantMemberChange, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectMemberChange, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectRoleChange, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UpdateUserEmailRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UpdateUserPhoneRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// ChangeUserUserName mocks base method
func (m *MockManagementServiceClient) ChangeUserUserName(arg0 context.Context, arg1 *management.UpdateUserUserNameRequest, arg2 ...grpc.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, "ChangeUserUserName", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CreateOIDCApplication mocks base method
func (m *MockManagementServiceClient) CreateOIDCApplication(arg0 context.Context, arg1 *management.OIDCApplicationCreate, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

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

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

// CreatePasswordAgePolicy mocks base method
func (m *MockManagementServiceClient) CreatePasswordAgePolicy(arg0 context.Context, arg1 *management.PasswordAgePolicyCreate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.PasswordComplexityPolicyCreate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.PasswordLockoutPolicyCreate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectCreateRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantCreate, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// CreateUser mocks base method
func (m *MockManagementServiceClient) CreateUser(arg0 context.Context, arg1 *management.CreateUserRequest, arg2 ...grpc.CallOption) (*management.UserResponse, 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].(*management.UserResponse)
	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 *management.UserGrantCreate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ApplicationID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

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

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

// DeactivateProject mocks base method
func (m *MockManagementServiceClient) DeactivateProject(arg0 context.Context, arg1 *management.ProjectID, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// DeactivateUser mocks base method
func (m *MockManagementServiceClient) DeactivateUser(arg0 context.Context, arg1 *management.UserID, arg2 ...grpc.CallOption) (*management.UserResponse, 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].(*management.UserResponse)
	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 *management.UserGrantID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// DeleteMachineKey mocks base method
func (m *MockManagementServiceClient) DeleteMachineKey(arg0 context.Context, arg1 *management.MachineKeyIDRequest, arg2 ...grpc.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, "DeleteMachineKey", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeletePasswordAgePolicy mocks base method
func (m *MockManagementServiceClient) DeletePasswordAgePolicy(arg0 context.Context, arg1 *management.PasswordAgePolicyID, arg2 ...grpc.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 *management.PasswordComplexityPolicyID, arg2 ...grpc.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 *management.PasswordLockoutPolicyID, arg2 ...grpc.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 *management.UserID, arg2 ...grpc.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...)
}

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

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

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

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

// GetGrantedProjectByID mocks base method
func (m *MockManagementServiceClient) GetGrantedProjectByID(arg0 context.Context, arg1 *management.ProjectGrantID, arg2 ...grpc.CallOption) (*management.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].(*management.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 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

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

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

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

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

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

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

// GetMyOrgIamPolicy mocks base method
func (m *MockManagementServiceClient) GetMyOrgIamPolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.Domain, arg2 ...grpc.CallOption) (*management.OrgView, 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].(*management.OrgView)
	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...)
}

// GetOrgMemberRoles mocks base method
func (m *MockManagementServiceClient) GetOrgMemberRoles(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*management.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].(*management.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 ...grpc.CallOption) (*management.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].(*management.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 ...grpc.CallOption) (*management.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].(*management.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 ...grpc.CallOption) (*management.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].(*management.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 ...grpc.CallOption) (*management.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].(*management.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 ...grpc.CallOption) (*management.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].(*management.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 *management.UserID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// GetUserByID mocks base method
func (m *MockManagementServiceClient) GetUserByID(arg0 context.Context, arg1 *management.UserID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

// GetUserEmail mocks base method
func (m *MockManagementServiceClient) GetUserEmail(arg0 context.Context, arg1 *management.UserID, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UserID, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UserID, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UserID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

// Healthz mocks base method
func (m *MockManagementServiceClient) Healthz(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.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...)
}

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

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

// IsUserUnique mocks base method
func (m *MockManagementServiceClient) IsUserUnique(arg0 context.Context, arg1 *management.UniqueUserRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UserID, arg2 ...grpc.CallOption) (*management.UserResponse, 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].(*management.UserResponse)
	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 *management.ChangeRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectID, arg2 ...grpc.CallOption) (*management.ProjectView, 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].(*management.ProjectView)
	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 *management.ChangeRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantID, arg2 ...grpc.CallOption) (*management.ProjectGrantView, 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].(*management.ProjectGrantView)
	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...)
}

// ReactivateApplication mocks base method
func (m *MockManagementServiceClient) ReactivateApplication(arg0 context.Context, arg1 *management.ApplicationID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

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

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

// ReactivateProject mocks base method
func (m *MockManagementServiceClient) ReactivateProject(arg0 context.Context, arg1 *management.ProjectID, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantID, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// ReactivateUser mocks base method
func (m *MockManagementServiceClient) ReactivateUser(arg0 context.Context, arg1 *management.UserID, arg2 ...grpc.CallOption) (*management.UserResponse, 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].(*management.UserResponse)
	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 *management.UserGrantID, arg2 ...grpc.CallOption) (*management.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].(*management.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 ...grpc.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 *management.ApplicationID, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ApplicationID, arg2 ...grpc.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...)
}

// RemoveExternalIDP mocks base method
func (m *MockManagementServiceClient) RemoveExternalIDP(arg0 context.Context, arg1 *management.ExternalIDPRemoveRequest, arg2 ...grpc.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, "RemoveExternalIDP", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveIdpConfig mocks base method
func (m *MockManagementServiceClient) RemoveIdpConfig(arg0 context.Context, arg1 *management.IdpID, arg2 ...grpc.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, "RemoveIdpConfig", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveIdpProviderFromLoginPolicy mocks base method
func (m *MockManagementServiceClient) RemoveIdpProviderFromLoginPolicy(arg0 context.Context, arg1 *management.IdpProviderID, arg2 ...grpc.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, "RemoveIdpProviderFromLoginPolicy", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveLoginPolicy mocks base method
func (m *MockManagementServiceClient) RemoveLoginPolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.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, "RemoveLoginPolicy", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveMyOrgDomain mocks base method
func (m *MockManagementServiceClient) RemoveMyOrgDomain(arg0 context.Context, arg1 *management.RemoveOrgDomainRequest, arg2 ...grpc.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 *management.RemoveOrgMemberRequest, arg2 ...grpc.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...)
}

// RemoveProject mocks base method
func (m *MockManagementServiceClient) RemoveProject(arg0 context.Context, arg1 *management.ProjectID, arg2 ...grpc.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, "RemoveProject", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveProjectGrant mocks base method
func (m *MockManagementServiceClient) RemoveProjectGrant(arg0 context.Context, arg1 *management.ProjectGrantID, arg2 ...grpc.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 *management.ProjectGrantMemberRemove, arg2 ...grpc.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 *management.ProjectMemberRemove, arg2 ...grpc.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 *management.ProjectRoleRemove, arg2 ...grpc.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 *management.UserGrantID, arg2 ...grpc.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...)
}

// RemoveUserPhone mocks base method
func (m *MockManagementServiceClient) RemoveUserPhone(arg0 context.Context, arg1 *management.UserID, arg2 ...grpc.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, "RemoveUserPhone", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResendEmailVerificationMail mocks base method
func (m *MockManagementServiceClient) ResendEmailVerificationMail(arg0 context.Context, arg1 *management.UserID, arg2 ...grpc.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 *management.UserID, arg2 ...grpc.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 *management.ApplicationSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// SearchGrantedProjects mocks base method
func (m *MockManagementServiceClient) SearchGrantedProjects(arg0 context.Context, arg1 *management.GrantedProjectSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

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

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

// SearchMyOrgDomains mocks base method
func (m *MockManagementServiceClient) SearchMyOrgDomains(arg0 context.Context, arg1 *management.OrgDomainSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.OrgMemberSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantMemberSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// SearchProjectGrants mocks base method
func (m *MockManagementServiceClient) SearchProjectGrants(arg0 context.Context, arg1 *management.ProjectGrantSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectMemberSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectRoleSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// SearchProjects mocks base method
func (m *MockManagementServiceClient) SearchProjects(arg0 context.Context, arg1 *management.ProjectSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

// SearchUserGrants mocks base method
func (m *MockManagementServiceClient) SearchUserGrants(arg0 context.Context, arg1 *management.UserGrantSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

// SearchUsers mocks base method
func (m *MockManagementServiceClient) SearchUsers(arg0 context.Context, arg1 *management.UserSearchRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.SetPasswordNotificationRequest, arg2 ...grpc.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 *management.PasswordRequest, arg2 ...grpc.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...)
}

// SetMyPrimaryOrgDomain mocks base method
func (m *MockManagementServiceClient) SetMyPrimaryOrgDomain(arg0 context.Context, arg1 *management.PrimaryOrgDomainRequest, arg2 ...grpc.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, "SetMyPrimaryOrgDomain", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UnlockUser mocks base method
func (m *MockManagementServiceClient) UnlockUser(arg0 context.Context, arg1 *management.UserID, arg2 ...grpc.CallOption) (*management.UserResponse, 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].(*management.UserResponse)
	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 *management.ApplicationUpdate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.OIDCConfigUpdate, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

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

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

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

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

// UpdatePasswordAgePolicy mocks base method
func (m *MockManagementServiceClient) UpdatePasswordAgePolicy(arg0 context.Context, arg1 *management.PasswordAgePolicyUpdate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.PasswordComplexityPolicyUpdate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.PasswordLockoutPolicyUpdate, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectUpdateRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ProjectGrantUpdate, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

// UpdateUserAddress mocks base method
func (m *MockManagementServiceClient) UpdateUserAddress(arg0 context.Context, arg1 *management.UpdateUserAddressRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UserGrantUpdate, arg2 ...grpc.CallOption) (*management.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].(*management.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...)
}

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

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

// UpdateUserProfile mocks base method
func (m *MockManagementServiceClient) UpdateUserProfile(arg0 context.Context, arg1 *management.UpdateUserProfileRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.ChangeRequest, arg2 ...grpc.CallOption) (*management.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].(*management.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 *management.UserGrantID, arg2 ...grpc.CallOption) (*management.UserGrantView, 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].(*management.UserGrantView)
	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 ...grpc.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...)
}

// ValidateMyOrgDomain mocks base method
func (m *MockManagementServiceClient) ValidateMyOrgDomain(arg0 context.Context, arg1 *management.ValidateOrgDomainRequest, arg2 ...grpc.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, "ValidateMyOrgDomain", varargs...)
	ret0, _ := ret[0].(*emptypb.Empty)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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