// 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" 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...) } // AddMultiFactorToLoginPolicy mocks base method func (m *MockManagementServiceClient) AddMultiFactorToLoginPolicy(arg0 context.Context, arg1 *management.MultiFactor, arg2 ...grpc.CallOption) (*management.MultiFactor, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AddMultiFactorToLoginPolicy", varargs...) ret0, _ := ret[0].(*management.MultiFactor) ret1, _ := ret[1].(error) return ret0, ret1 } // AddMultiFactorToLoginPolicy indicates an expected call of AddMultiFactorToLoginPolicy func (mr *MockManagementServiceClientMockRecorder) AddMultiFactorToLoginPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMultiFactorToLoginPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).AddMultiFactorToLoginPolicy), 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...) } // AddSecondFactorToLoginPolicy mocks base method func (m *MockManagementServiceClient) AddSecondFactorToLoginPolicy(arg0 context.Context, arg1 *management.SecondFactor, arg2 ...grpc.CallOption) (*management.SecondFactor, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AddSecondFactorToLoginPolicy", varargs...) ret0, _ := ret[0].(*management.SecondFactor) ret1, _ := ret[1].(error) return ret0, ret1 } // AddSecondFactorToLoginPolicy indicates an expected call of AddSecondFactorToLoginPolicy func (mr *MockManagementServiceClientMockRecorder) AddSecondFactorToLoginPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSecondFactorToLoginPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).AddSecondFactorToLoginPolicy), 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.LoginPolicyRequest, 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.PasswordAgePolicyRequest, 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.PasswordComplexityPolicyRequest, 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.PasswordLockoutPolicyRequest, 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...) } // 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...) } // GetDefaultLoginPolicy mocks base method func (m *MockManagementServiceClient) GetDefaultLoginPolicy(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, "GetDefaultLoginPolicy", varargs...) ret0, _ := ret[0].(*management.LoginPolicyView) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDefaultLoginPolicy indicates an expected call of GetDefaultLoginPolicy func (mr *MockManagementServiceClientMockRecorder) GetDefaultLoginPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultLoginPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).GetDefaultLoginPolicy), varargs...) } // GetDefaultPasswordAgePolicy mocks base method func (m *MockManagementServiceClient) GetDefaultPasswordAgePolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*management.PasswordAgePolicyView, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetDefaultPasswordAgePolicy", varargs...) ret0, _ := ret[0].(*management.PasswordAgePolicyView) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDefaultPasswordAgePolicy indicates an expected call of GetDefaultPasswordAgePolicy func (mr *MockManagementServiceClientMockRecorder) GetDefaultPasswordAgePolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultPasswordAgePolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).GetDefaultPasswordAgePolicy), varargs...) } // GetDefaultPasswordComplexityPolicy mocks base method func (m *MockManagementServiceClient) GetDefaultPasswordComplexityPolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*management.PasswordComplexityPolicyView, 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.PasswordComplexityPolicyView) 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...) } // GetDefaultPasswordLockoutPolicy mocks base method func (m *MockManagementServiceClient) GetDefaultPasswordLockoutPolicy(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*management.PasswordLockoutPolicyView, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetDefaultPasswordLockoutPolicy", varargs...) ret0, _ := ret[0].(*management.PasswordLockoutPolicyView) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDefaultPasswordLockoutPolicy indicates an expected call of GetDefaultPasswordLockoutPolicy func (mr *MockManagementServiceClientMockRecorder) GetDefaultPasswordLockoutPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultPasswordLockoutPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).GetDefaultPasswordLockoutPolicy), 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...) } // GetLoginPolicyMultiFactors mocks base method func (m *MockManagementServiceClient) GetLoginPolicyMultiFactors(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*management.MultiFactorsResult, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetLoginPolicyMultiFactors", varargs...) ret0, _ := ret[0].(*management.MultiFactorsResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetLoginPolicyMultiFactors indicates an expected call of GetLoginPolicyMultiFactors func (mr *MockManagementServiceClientMockRecorder) GetLoginPolicyMultiFactors(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoginPolicyMultiFactors", reflect.TypeOf((*MockManagementServiceClient)(nil).GetLoginPolicyMultiFactors), varargs...) } // GetLoginPolicySecondFactors mocks base method func (m *MockManagementServiceClient) GetLoginPolicySecondFactors(arg0 context.Context, arg1 *emptypb.Empty, arg2 ...grpc.CallOption) (*management.SecondFactorsResult, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetLoginPolicySecondFactors", varargs...) ret0, _ := ret[0].(*management.SecondFactorsResult) ret1, _ := ret[1].(error) return ret0, ret1 } // GetLoginPolicySecondFactors indicates an expected call of GetLoginPolicySecondFactors func (mr *MockManagementServiceClientMockRecorder) GetLoginPolicySecondFactors(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLoginPolicySecondFactors", reflect.TypeOf((*MockManagementServiceClient)(nil).GetLoginPolicySecondFactors), 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.OrgIamPolicyView, 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.OrgIamPolicyView) 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.PasswordAgePolicyView, 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.PasswordAgePolicyView) 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.PasswordComplexityPolicyView, 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.PasswordComplexityPolicyView) 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.PasswordLockoutPolicyView, 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.PasswordLockoutPolicyView) 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.UserMultiFactors, 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.UserMultiFactors) 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...) } // 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...) } // RemoveMultiFactorFromLoginPolicy mocks base method func (m *MockManagementServiceClient) RemoveMultiFactorFromLoginPolicy(arg0 context.Context, arg1 *management.MultiFactor, 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, "RemoveMultiFactorFromLoginPolicy", varargs...) ret0, _ := ret[0].(*emptypb.Empty) ret1, _ := ret[1].(error) return ret0, ret1 } // RemoveMultiFactorFromLoginPolicy indicates an expected call of RemoveMultiFactorFromLoginPolicy func (mr *MockManagementServiceClientMockRecorder) RemoveMultiFactorFromLoginPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMultiFactorFromLoginPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).RemoveMultiFactorFromLoginPolicy), 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...) } // RemovePasswordAgePolicy mocks base method func (m *MockManagementServiceClient) RemovePasswordAgePolicy(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, "RemovePasswordAgePolicy", varargs...) ret0, _ := ret[0].(*emptypb.Empty) ret1, _ := ret[1].(error) return ret0, ret1 } // RemovePasswordAgePolicy indicates an expected call of RemovePasswordAgePolicy func (mr *MockManagementServiceClientMockRecorder) RemovePasswordAgePolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePasswordAgePolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).RemovePasswordAgePolicy), varargs...) } // RemovePasswordComplexityPolicy mocks base method func (m *MockManagementServiceClient) RemovePasswordComplexityPolicy(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, "RemovePasswordComplexityPolicy", varargs...) ret0, _ := ret[0].(*emptypb.Empty) ret1, _ := ret[1].(error) return ret0, ret1 } // RemovePasswordComplexityPolicy indicates an expected call of RemovePasswordComplexityPolicy func (mr *MockManagementServiceClientMockRecorder) RemovePasswordComplexityPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePasswordComplexityPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).RemovePasswordComplexityPolicy), varargs...) } // RemovePasswordLockoutPolicy mocks base method func (m *MockManagementServiceClient) RemovePasswordLockoutPolicy(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, "RemovePasswordLockoutPolicy", varargs...) ret0, _ := ret[0].(*emptypb.Empty) ret1, _ := ret[1].(error) return ret0, ret1 } // RemovePasswordLockoutPolicy indicates an expected call of RemovePasswordLockoutPolicy func (mr *MockManagementServiceClientMockRecorder) RemovePasswordLockoutPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemovePasswordLockoutPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).RemovePasswordLockoutPolicy), 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...) } // RemoveSecondFactorFromLoginPolicy mocks base method func (m *MockManagementServiceClient) RemoveSecondFactorFromLoginPolicy(arg0 context.Context, arg1 *management.SecondFactor, 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, "RemoveSecondFactorFromLoginPolicy", varargs...) ret0, _ := ret[0].(*emptypb.Empty) ret1, _ := ret[1].(error) return ret0, ret1 } // RemoveSecondFactorFromLoginPolicy indicates an expected call of RemoveSecondFactorFromLoginPolicy func (mr *MockManagementServiceClientMockRecorder) RemoveSecondFactorFromLoginPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSecondFactorFromLoginPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).RemoveSecondFactorFromLoginPolicy), 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...) } // ResendInitialMail mocks base method func (m *MockManagementServiceClient) ResendInitialMail(arg0 context.Context, arg1 *management.InitialMailRequest, 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, "ResendInitialMail", varargs...) ret0, _ := ret[0].(*emptypb.Empty) ret1, _ := ret[1].(error) return ret0, ret1 } // ResendInitialMail indicates an expected call of ResendInitialMail func (mr *MockManagementServiceClientMockRecorder) ResendInitialMail(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendInitialMail", reflect.TypeOf((*MockManagementServiceClient)(nil).ResendInitialMail), 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.LoginPolicyRequest, 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.PasswordAgePolicyRequest, 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.PasswordComplexityPolicyRequest, 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.PasswordLockoutPolicyRequest, 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...) } // 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...) }