diff --git a/pkg/admin/api/grpc/admin.pb.authoptions.go b/pkg/admin/api/grpc/admin.pb.authoptions.go new file mode 100644 index 0000000000..c6e9605061 --- /dev/null +++ b/pkg/admin/api/grpc/admin.pb.authoptions.go @@ -0,0 +1,20 @@ +// Code generated by protoc-gen-authmethod. DO NOT EDIT. + +package grpc + +import ( + "google.golang.org/grpc" + + utils_auth "github.com/caos/citadel/utils/auth" + utils_grpc "github.com/caos/citadel/utils/grpc" +) + +/** + * AdminService + */ + +var AdminService_AuthMethods = utils_auth.AuthMethodMapping{} + +func AdminService_Authorization_Interceptor(verifier utils_auth.TokenVerifier, authConf *utils_auth.AuthConfig) grpc.UnaryServerInterceptor { + return utils_grpc.AuthorizationInterceptor(verifier, authConf, AdminService_AuthMethods) +} diff --git a/pkg/admin/api/grpc/admin.swagger.json b/pkg/admin/api/grpc/admin.swagger.json new file mode 100644 index 0000000000..cd274e4e42 --- /dev/null +++ b/pkg/admin/api/grpc/admin.swagger.json @@ -0,0 +1,141 @@ +{ + "swagger": "2.0", + "info": { + "title": "admin service", + "version": "0.1", + "contact": { + "url": "https://github.com/caos/citadel/admin" + } + }, + "schemes": [ + "https" + ], + "consumes": [ + "application/json", + "application/grpc" + ], + "produces": [ + "application/json", + "application/grpc" + ], + "paths": { + "/healthz": { + "get": { + "summary": "Healthz returns status OK as soon as the service started", + "operationId": "Healthz", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "tags": [ + "AdminService" + ] + } + }, + "/ready": { + "get": { + "summary": "Ready returns status OK as soon as all dependent services are available", + "operationId": "Ready", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "tags": [ + "AdminService" + ] + } + }, + "/validate": { + "get": { + "operationId": "Validate", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/protobufStruct" + } + } + }, + "tags": [ + "AdminService" + ] + } + } + }, + "definitions": { + "protobufListValue": { + "type": "object", + "properties": { + "values": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufValue" + }, + "description": "Repeated field of dynamically typed values." + } + }, + "description": "`ListValue` is a wrapper around a repeated field of values.\n\nThe JSON representation for `ListValue` is JSON array." + }, + "protobufNullValue": { + "type": "string", + "enum": [ + "NULL_VALUE" + ], + "default": "NULL_VALUE", + "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value." + }, + "protobufStruct": { + "type": "object", + "properties": { + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/protobufValue" + }, + "description": "Unordered map of dynamically typed values." + } + }, + "description": "`Struct` represents a structured data value, consisting of fields\nwhich map to dynamically typed values. In some languages, `Struct`\nmight be supported by a native representation. For example, in\nscripting languages like JS a struct is represented as an\nobject. The details of that representation are described together\nwith the proto support for the language.\n\nThe JSON representation for `Struct` is JSON object." + }, + "protobufValue": { + "type": "object", + "properties": { + "null_value": { + "$ref": "#/definitions/protobufNullValue", + "description": "Represents a null value." + }, + "number_value": { + "type": "number", + "format": "double", + "description": "Represents a double value." + }, + "string_value": { + "type": "string", + "description": "Represents a string value." + }, + "bool_value": { + "type": "boolean", + "format": "boolean", + "description": "Represents a boolean value." + }, + "struct_value": { + "$ref": "#/definitions/protobufStruct", + "description": "Represents a structured value." + }, + "list_value": { + "$ref": "#/definitions/protobufListValue", + "description": "Represents a repeated `Value`." + } + }, + "description": "`Value` represents a dynamically typed value which can be either\nnull, a number, a string, a boolean, a recursive struct value, or a\nlist of values. A producer of value is expected to set one of that\nvariants, absence of any variant indicates an error.\n\nThe JSON representation for `Value` is JSON value." + } + } +} diff --git a/pkg/admin/api/grpc/mock/admin.proto.mock.go b/pkg/admin/api/grpc/mock/admin.proto.mock.go new file mode 100644 index 0000000000..e590f7ca3f --- /dev/null +++ b/pkg/admin/api/grpc/mock/admin.proto.mock.go @@ -0,0 +1,178 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/caos/citadel/admin/api/grpc (interfaces: AdminServiceClient) + +// Package api is a generated GoMock package. +package api + +import ( + context "context" + grpc "github.com/caos/citadel/admin/api/grpc" + gomock "github.com/golang/mock/gomock" + empty "github.com/golang/protobuf/ptypes/empty" + struct0 "github.com/golang/protobuf/ptypes/struct" + grpc0 "google.golang.org/grpc" + reflect "reflect" +) + +// MockAdminServiceClient is a mock of AdminServiceClient interface +type MockAdminServiceClient struct { + ctrl *gomock.Controller + recorder *MockAdminServiceClientMockRecorder +} + +// MockAdminServiceClientMockRecorder is the mock recorder for MockAdminServiceClient +type MockAdminServiceClientMockRecorder struct { + mock *MockAdminServiceClient +} + +// NewMockAdminServiceClient creates a new mock instance +func NewMockAdminServiceClient(ctrl *gomock.Controller) *MockAdminServiceClient { + mock := &MockAdminServiceClient{ctrl: ctrl} + mock.recorder = &MockAdminServiceClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use +func (m *MockAdminServiceClient) EXPECT() *MockAdminServiceClientMockRecorder { + return m.recorder +} + +// GetOrgByID mocks base method +func (m *MockAdminServiceClient) GetOrgByID(arg0 context.Context, arg1 *grpc.OrgID, arg2 ...grpc0.CallOption) (*grpc.Org, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOrgByID", varargs...) + ret0, _ := ret[0].(*grpc.Org) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrgByID indicates an expected call of GetOrgByID +func (mr *MockAdminServiceClientMockRecorder) GetOrgByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgByID", reflect.TypeOf((*MockAdminServiceClient)(nil).GetOrgByID), varargs...) +} + +// Healthz mocks base method +func (m *MockAdminServiceClient) Healthz(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Healthz indicates an expected call of Healthz +func (mr *MockAdminServiceClientMockRecorder) 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((*MockAdminServiceClient)(nil).Healthz), varargs...) +} + +// IsOrgUnique mocks base method +func (m *MockAdminServiceClient) IsOrgUnique(arg0 context.Context, arg1 *grpc.UniqueOrgRequest, arg2 ...grpc0.CallOption) (*grpc.UniqueOrgResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "IsOrgUnique", varargs...) + ret0, _ := ret[0].(*grpc.UniqueOrgResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// IsOrgUnique indicates an expected call of IsOrgUnique +func (mr *MockAdminServiceClientMockRecorder) IsOrgUnique(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsOrgUnique", reflect.TypeOf((*MockAdminServiceClient)(nil).IsOrgUnique), varargs...) +} + +// Ready mocks base method +func (m *MockAdminServiceClient) Ready(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Ready", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Ready indicates an expected call of Ready +func (mr *MockAdminServiceClientMockRecorder) Ready(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockAdminServiceClient)(nil).Ready), varargs...) +} + +// SearchOrgs mocks base method +func (m *MockAdminServiceClient) SearchOrgs(arg0 context.Context, arg1 *grpc.OrgSearchRequest, arg2 ...grpc0.CallOption) (*grpc.OrgSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchOrgs", varargs...) + ret0, _ := ret[0].(*grpc.OrgSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchOrgs indicates an expected call of SearchOrgs +func (mr *MockAdminServiceClientMockRecorder) SearchOrgs(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchOrgs", reflect.TypeOf((*MockAdminServiceClient)(nil).SearchOrgs), varargs...) +} + +// SetUpOrg mocks base method +func (m *MockAdminServiceClient) SetUpOrg(arg0 context.Context, arg1 *grpc.OrgSetUpRequest, arg2 ...grpc0.CallOption) (*grpc.OrgSetUpResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetUpOrg", varargs...) + ret0, _ := ret[0].(*grpc.OrgSetUpResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetUpOrg indicates an expected call of SetUpOrg +func (mr *MockAdminServiceClientMockRecorder) SetUpOrg(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpOrg", reflect.TypeOf((*MockAdminServiceClient)(nil).SetUpOrg), varargs...) +} + +// Validate mocks base method +func (m *MockAdminServiceClient) Validate(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*struct0.Struct, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Validate", varargs...) + ret0, _ := ret[0].(*struct0.Struct) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Validate indicates an expected call of Validate +func (mr *MockAdminServiceClientMockRecorder) Validate(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*MockAdminServiceClient)(nil).Validate), varargs...) +} diff --git a/pkg/management/api/grpc/management.pb.authoptions.go b/pkg/management/api/grpc/management.pb.authoptions.go new file mode 100644 index 0000000000..4ec638da86 --- /dev/null +++ b/pkg/management/api/grpc/management.pb.authoptions.go @@ -0,0 +1,521 @@ +// Code generated by protoc-gen-authmethod. DO NOT EDIT. + +package grpc + +import ( + "google.golang.org/grpc" + + utils_auth "github.com/caos/citadel/utils/auth" + utils_grpc "github.com/caos/citadel/utils/grpc" +) + +/** + * ManagementService + */ + +var ManagementService_AuthMethods = utils_auth.AuthMethodMapping{ + + "/caos.citadel.management.api.v1.ManagementService/GetUserByID": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetUserByEmailGlobal": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchUsers": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/IsUserUnique": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreateUser": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateUser": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateUser": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/LockUser": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UnlockUser": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeleteUser": utils_auth.AuthOption{ + Permission: "user.delete", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UserChanges": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ApplicationChanges": utils_auth.AuthOption{ + Permission: "project.app.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/OrgChanges": utils_auth.AuthOption{ + Permission: "org.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ProjectChanges": utils_auth.AuthOption{ + Permission: "project.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetUserProfile": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateUserProfile": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetUserEmail": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ChangeUserEmail": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ResendEmailVerificationMail": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetUserPhone": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ChangeUserPhone": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ResendPhoneVerificationCode": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetUserAddress": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateUserAddress": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetUserMfas": utils_auth.AuthOption{ + Permission: "user.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SendSetPasswordNotification": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SetInitialPassword": utils_auth.AuthOption{ + Permission: "user.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetPasswordComplexityPolicy": utils_auth.AuthOption{ + Permission: "policy.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreatePasswordComplexityPolicy": utils_auth.AuthOption{ + Permission: "policy.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdatePasswordComplexityPolicy": utils_auth.AuthOption{ + Permission: "policy.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeletePasswordComplexityPolicy": utils_auth.AuthOption{ + Permission: "policy.delete", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetPasswordAgePolicy": utils_auth.AuthOption{ + Permission: "policy.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreatePasswordAgePolicy": utils_auth.AuthOption{ + Permission: "policy.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdatePasswordAgePolicy": utils_auth.AuthOption{ + Permission: "policy.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeletePasswordAgePolicy": utils_auth.AuthOption{ + Permission: "policy.delete", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetPasswordLockoutPolicy": utils_auth.AuthOption{ + Permission: "policy.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreatePasswordLockoutPolicy": utils_auth.AuthOption{ + Permission: "policy.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdatePasswordLockoutPolicy": utils_auth.AuthOption{ + Permission: "policy.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeletePasswordLockoutPolicy": utils_auth.AuthOption{ + Permission: "policy.delete", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetOrgByID": utils_auth.AuthOption{ + Permission: "org.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetOrgByDomainGlobal": utils_auth.AuthOption{ + Permission: "org.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateOrg": utils_auth.AuthOption{ + Permission: "org.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateOrg": utils_auth.AuthOption{ + Permission: "org.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetOrgMemberRoles": utils_auth.AuthOption{ + Permission: "org.member.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/AddOrgMember": utils_auth.AuthOption{ + Permission: "org.member.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ChangeOrgMember": utils_auth.AuthOption{ + Permission: "org.member.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/RemoveOrgMember": utils_auth.AuthOption{ + Permission: "org.member.delete", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchOrgMembers": utils_auth.AuthOption{ + Permission: "org.member.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchProjects": utils_auth.AuthOption{ + Permission: "project.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ProjectByID": utils_auth.AuthOption{ + Permission: "project.read", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreateProject": utils_auth.AuthOption{ + Permission: "project.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateProject": utils_auth.AuthOption{ + Permission: "project.write", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateProject": utils_auth.AuthOption{ + Permission: "project.write", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateProject": utils_auth.AuthOption{ + Permission: "project.write", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetGrantedProjectGrantByID": utils_auth.AuthOption{ + Permission: "project.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetProjectMemberRoles": utils_auth.AuthOption{ + Permission: "project.member.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchProjectMembers": utils_auth.AuthOption{ + Permission: "project.member.read", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/AddProjectMember": utils_auth.AuthOption{ + Permission: "project.member.write", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/ChangeProjectMember": utils_auth.AuthOption{ + Permission: "project.member.write", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/RemoveProjectMember": utils_auth.AuthOption{ + Permission: "project.member.delete", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchProjectRoles": utils_auth.AuthOption{ + Permission: "project.role.read", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/AddProjectRole": utils_auth.AuthOption{ + Permission: "project.role.write", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/RemoveProjectRole": utils_auth.AuthOption{ + Permission: "project.role.delete", + CheckParam: "Id", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchApplications": utils_auth.AuthOption{ + Permission: "project.app.read", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/ApplicationByID": utils_auth.AuthOption{ + Permission: "project.app.read", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreateOIDCApplication": utils_auth.AuthOption{ + Permission: "project.app.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateApplication": utils_auth.AuthOption{ + Permission: "project.app.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateApplication": utils_auth.AuthOption{ + Permission: "project.app.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateApplication": utils_auth.AuthOption{ + Permission: "project.app.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateApplicationOIDCConfig": utils_auth.AuthOption{ + Permission: "project.app.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/RegenerateOIDCClientSecret": utils_auth.AuthOption{ + Permission: "project.app.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchProjectGrants": utils_auth.AuthOption{ + Permission: "project.grant.read", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/ProjectGrantByID": utils_auth.AuthOption{ + Permission: "project.grant.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreateProjectGrant": utils_auth.AuthOption{ + Permission: "project.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateProjectGrant": utils_auth.AuthOption{ + Permission: "project.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateProjectGrant": utils_auth.AuthOption{ + Permission: "project.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateProjectGrant": utils_auth.AuthOption{ + Permission: "project.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/GetProjectGrantMemberRoles": utils_auth.AuthOption{ + Permission: "project.grant.member.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchProjectGrantMembers": utils_auth.AuthOption{ + Permission: "project.grant.member.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/AddProjectGrantMember": utils_auth.AuthOption{ + Permission: "project.grant.member.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ChangeProjectGrantMember": utils_auth.AuthOption{ + Permission: "project.grant.member.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/RemoveProjectGrantMember": utils_auth.AuthOption{ + Permission: "project.grant.member.delete", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchUserGrants": utils_auth.AuthOption{ + Permission: "user.grant.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UserGrantByID": utils_auth.AuthOption{ + Permission: "user.grant.read", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreateUserGrant": utils_auth.AuthOption{ + Permission: "user.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateUserGrant": utils_auth.AuthOption{ + Permission: "user.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateUserGrant": utils_auth.AuthOption{ + Permission: "user.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateUserGrant": utils_auth.AuthOption{ + Permission: "user.grant.write", + CheckParam: "", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchProjectUserGrants": utils_auth.AuthOption{ + Permission: "project.user.grant.read", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/ProjectUserGrantByID": utils_auth.AuthOption{ + Permission: "project.user.grant.read", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreateProjectUserGrant": utils_auth.AuthOption{ + Permission: "project.user.grant.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateProjectUserGrant": utils_auth.AuthOption{ + Permission: "project.user.grant.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateProjectUserGrant": utils_auth.AuthOption{ + Permission: "project.user.grant.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateProjectUserGrant": utils_auth.AuthOption{ + Permission: "project.user.grant.write", + CheckParam: "ProjectId", + }, + + "/caos.citadel.management.api.v1.ManagementService/SearchProjectGrantUserGrants": utils_auth.AuthOption{ + Permission: "project.grant.user.grant.read", + CheckParam: "ProjectGrantId", + }, + + "/caos.citadel.management.api.v1.ManagementService/ProjectGrantUserGrantByID": utils_auth.AuthOption{ + Permission: "project.grant.user.grant.read", + CheckParam: "ProjectGrantId", + }, + + "/caos.citadel.management.api.v1.ManagementService/CreateProjectGrantUserGrant": utils_auth.AuthOption{ + Permission: "project.grant.user.grant.write", + CheckParam: "ProjectGrantId", + }, + + "/caos.citadel.management.api.v1.ManagementService/UpdateProjectGrantUserGrant": utils_auth.AuthOption{ + Permission: "project.grant.user.grant.write", + CheckParam: "ProjectGrantId", + }, + + "/caos.citadel.management.api.v1.ManagementService/DeactivateProjectGrantUserGrant": utils_auth.AuthOption{ + Permission: "project.grant.user.grant.write", + CheckParam: "ProjectGrantId", + }, + + "/caos.citadel.management.api.v1.ManagementService/ReactivateProjectGrantUserGrant": utils_auth.AuthOption{ + Permission: "project.grant.user.grant.write", + CheckParam: "ProjectGrantId", + }, +} + +func ManagementService_Authorization_Interceptor(verifier utils_auth.TokenVerifier, authConf *utils_auth.AuthConfig) grpc.UnaryServerInterceptor { + return utils_grpc.AuthorizationInterceptor(verifier, authConf, ManagementService_AuthMethods) +} diff --git a/pkg/management/api/grpc/management.swagger.json b/pkg/management/api/grpc/management.swagger.json new file mode 100644 index 0000000000..59c6222d4d --- /dev/null +++ b/pkg/management/api/grpc/management.swagger.json @@ -0,0 +1,5657 @@ +{ + "swagger": "2.0", + "info": { + "title": "Management API", + "version": "0.1", + "contact": { + "url": "https://github.com/caos/citadel/management" + } + }, + "schemes": [ + "https" + ], + "consumes": [ + "application/json", + "application/grpc" + ], + "produces": [ + "application/json", + "application/grpc" + ], + "paths": { + "/applications/{id}/changes": { + "get": { + "operationId": "ApplicationChanges", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Changes" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "limit", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "sequence_offset", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/authgrants/_search": { + "post": { + "summary": "Grant", + "operationId": "SearchAuthGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1AuthGrantSearchResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1AuthGrantSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/global/orgs/domain/{domain}": { + "get": { + "operationId": "GetOrgByDomainGlobal", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Org" + } + } + }, + "parameters": [ + { + "name": "domain", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/global/users/email/{email}": { + "get": { + "operationId": "GetUserByEmailGlobal", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1User" + } + } + }, + "parameters": [ + { + "name": "email", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/grants/{id}": { + "get": { + "summary": "GRANTED_PROJECT_GRANTS", + "operationId": "GetGrantedProjectGrantByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrant" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/healthz": { + "get": { + "summary": "READINESS", + "operationId": "Healthz", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/members/roles": { + "get": { + "summary": "ORG_MEMBERS", + "operationId": "GetOrgMemberRoles", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1OrgMemberRoles" + } + } + }, + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/{id}": { + "get": { + "summary": "ORG", + "operationId": "GetOrgByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Org" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/{id}/_deactivate": { + "put": { + "operationId": "DeactivateOrg", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Org" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1OrgID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/{id}/_reactivate": { + "put": { + "operationId": "ReactivateOrg", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Org" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1OrgID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/{id}/changes": { + "get": { + "operationId": "OrgChanges", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Changes" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "limit", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "sequence_offset", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/{org_id}/members": { + "post": { + "operationId": "AddOrgMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "org_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1AddOrgMemberRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/{org_id}/members/_search": { + "post": { + "operationId": "SearchOrgMembers", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1OrgMemberSearchResponse" + } + } + }, + "parameters": [ + { + "name": "org_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1OrgMemberSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/orgs/{org_id}/members/{user_id}": { + "delete": { + "operationId": "RemoveOrgMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "org_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "ChangeOrgMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "org_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ChangeOrgMemberRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/policies/passwords/age": { + "get": { + "summary": "PASSWORD_AGE_POLICY", + "operationId": "GetPasswordAgePolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordAgePolicy" + } + } + }, + "tags": [ + "ManagementService" + ] + }, + "post": { + "operationId": "CreatePasswordAgePolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordAgePolicy" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1PasswordAgePolicyCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/policies/passwords/age/{id}": { + "delete": { + "operationId": "DeletePasswordAgePolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdatePasswordAgePolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordAgePolicy" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1PasswordAgePolicyUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/policies/passwords/complexity": { + "get": { + "summary": "PASSWORD_COMPLEXITY_POLICY", + "operationId": "GetPasswordComplexityPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordComplexityPolicy" + } + } + }, + "tags": [ + "ManagementService" + ] + }, + "post": { + "operationId": "CreatePasswordComplexityPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordComplexityPolicy" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1PasswordComplexityPolicyCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/policies/passwords/complexity/{id}": { + "delete": { + "operationId": "DeletePasswordComplexityPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdatePasswordComplexityPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordComplexityPolicy" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1PasswordComplexityPolicyUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/policies/passwords/lockout": { + "get": { + "summary": "PASSWORD_LOCKOUT_POLICY", + "operationId": "GetPasswordLockoutPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordLockoutPolicy" + } + } + }, + "tags": [ + "ManagementService" + ] + }, + "post": { + "operationId": "CreatePasswordLockoutPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordLockoutPolicy" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1PasswordLockoutPolicyCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/policies/passwords/lockout/{id}": { + "delete": { + "operationId": "DeletePasswordLockoutPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdatePasswordLockoutPolicy", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1PasswordLockoutPolicy" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1PasswordLockoutPolicyUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projectgrants/{project_grant_id}/users/grants/_search": { + "post": { + "summary": "PROJECT_GRANT_USER_GRANT", + "operationId": "SearchProjectGrantUserGrants", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrantSearchResponse" + } + } + }, + "parameters": [ + { + "name": "project_grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantUserGrantSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projectgrants/{project_grant_id}/users/{user_id}/grants": { + "post": { + "operationId": "CreateProjectGrantUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantUserGrantCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projectgrants/{project_grant_id}/users/{user_id}/grants/{id}": { + "get": { + "operationId": "ProjectGrantUserGrantByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateProjectGrantUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantUserGrantUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projectgrants/{project_grant_id}/users/{user_id}/grants/{id}/_deactivate": { + "put": { + "operationId": "DeactivateProjectGrantUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantUserGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projectgrants/{project_grant_id}/users/{user_id}/grants/{id}/_reactivate": { + "put": { + "operationId": "ReactivateProjectGrantUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantUserGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects": { + "post": { + "operationId": "CreateProject", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Project" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectCreateRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/_search": { + "post": { + "summary": "PROJECTS", + "operationId": "SearchProjects", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectSearchResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/grants/members/roles": { + "get": { + "summary": "PROJECT_GRANT_MEMBER", + "operationId": "GetProjectGrantMemberRoles", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrantMemberRoles" + } + } + }, + "tags": [ + "ManagementService" + ] + } + }, + "/projects/members/roles": { + "get": { + "summary": "PROJECT_MEMBERS", + "operationId": "GetProjectMemberRoles", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectMemberRoles" + } + } + }, + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}": { + "get": { + "operationId": "ProjectByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Project" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateProject", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Project" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectUpdateRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}/_deactivate": { + "put": { + "operationId": "DeactivateProject", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Project" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}/_reactivate": { + "put": { + "operationId": "ReactivateProject", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Project" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}/changes": { + "get": { + "operationId": "ProjectChanges", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Changes" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "limit", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "sequence_offset", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}/members": { + "post": { + "operationId": "AddProjectMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectMemberAdd" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}/members/{user_id}": { + "delete": { + "operationId": "RemoveProjectMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "ChangeProjectMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectMemberChange" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}/roles": { + "post": { + "operationId": "AddProjectRole", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectRoleAdd" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{id}/roles/{name}": { + "delete": { + "operationId": "RemoveProjectRole", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "name", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/applications/_search": { + "post": { + "summary": "APPLICATIONS", + "operationId": "SearchApplications", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ApplicationSearchResponse" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ApplicationSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/applications/{application_id}/oidcconfig": { + "put": { + "operationId": "UpdateApplicationOIDCConfig", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1OIDCConfig" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "application_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1OIDCConfigUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/applications/{id}": { + "get": { + "operationId": "ApplicationByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Application" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateApplication", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Application" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ApplicationUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/applications/{id}/_deactivate": { + "put": { + "operationId": "DeactivateApplication", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Application" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ApplicationID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/applications/{id}/_reactivate": { + "put": { + "operationId": "ReactivateApplication", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Application" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ApplicationID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/applications/{id}/oidcconfig/_changeclientsecret": { + "put": { + "operationId": "RegenerateOIDCClientSecret", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ClientSecret" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ApplicationID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants": { + "post": { + "operationId": "CreateProjectGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants/_search": { + "post": { + "summary": "PROJECT_GRANT", + "operationId": "SearchProjectGrants", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrantSearchResponse" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants/{grant_id}/members": { + "post": { + "operationId": "AddProjectGrantMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantMemberAdd" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants/{grant_id}/members/_search": { + "post": { + "operationId": "SearchProjectGrantMembers", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrantMemberSearchResponse" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantMemberSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants/{grant_id}/members/{user_id}": { + "delete": { + "operationId": "RemoveProjectGrantMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "ChangeProjectGrantMember", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "grant_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantMemberChange" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants/{id}": { + "get": { + "operationId": "ProjectGrantByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateProjectGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants/{id}/_deactivate": { + "put": { + "operationId": "DeactivateProjectGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/grants/{id}/_reactivate": { + "put": { + "operationId": "ReactivateProjectGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/members/_search": { + "post": { + "operationId": "SearchProjectMembers", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectMemberSearchResponse" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectMemberSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/oidcapplications": { + "post": { + "operationId": "CreateOIDCApplication", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Application" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1OIDCApplicationCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/roles/_search": { + "post": { + "summary": "PROJECT_ROLES", + "operationId": "SearchProjectRoles", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1ProjectRoleSearchResponse" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectRoleSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/users/grants/_search": { + "post": { + "summary": "PROJECT_USER_GRANT", + "operationId": "SearchProjectUserGrants", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrantSearchResponse" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectUserGrantSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/users/{user_id}/grants": { + "post": { + "operationId": "CreateProjectUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserGrantCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/users/{user_id}/grants/{id}": { + "get": { + "operationId": "ProjectUserGrantByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateProjectUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectUserGrantUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/users/{user_id}/grants/{id}/_deactivate": { + "put": { + "operationId": "DeactivateProjectUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectUserGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/projects/{project_id}/users/{user_id}/grants/{id}/_reactivate": { + "put": { + "operationId": "ReactivateProjectUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "project_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1ProjectUserGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/ready": { + "get": { + "operationId": "Ready", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "tags": [ + "ManagementService" + ] + } + }, + "/users": { + "post": { + "operationId": "CreateUser", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1User" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1CreateUserRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/_isunique": { + "get": { + "operationId": "IsUserUnique", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UniqueUserResponse" + } + } + }, + "parameters": [ + { + "name": "user_name", + "in": "query", + "required": false, + "type": "string" + }, + { + "name": "email", + "in": "query", + "required": false, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/_search": { + "post": { + "operationId": "SearchUsers", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserSearchResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/grants/_search": { + "post": { + "summary": "USER_GRANT", + "operationId": "SearchUserGrants", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrantSearchResponse" + } + } + }, + "parameters": [ + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserGrantSearchRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}": { + "get": { + "summary": "USER", + "operationId": "GetUserByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1User" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "delete": { + "operationId": "DeleteUser", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/_deactivate": { + "put": { + "operationId": "DeactivateUser", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1User" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/_lock": { + "put": { + "operationId": "LockUser", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1User" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/_reactivate": { + "put": { + "operationId": "ReactivateUser", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1User" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/_sendsetpwnotify": { + "post": { + "summary": "PASSWORD\nSends an Notification (Email/SMS) with a password reset Link", + "operationId": "SendSetPasswordNotification", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1SetPasswordNotificationRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/_setinitialpw": { + "post": { + "summary": "A Manager is only allowed to set an initial password, on the next login the user has to change his password", + "operationId": "SetInitialPassword", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1PasswordRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/_unlock": { + "put": { + "operationId": "UnlockUser", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1User" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/address": { + "get": { + "summary": "USER_ADDRESS", + "operationId": "GetUserAddress", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserAddress" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateUserAddress", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserAddress" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UpdateUserAddressRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/changes": { + "get": { + "operationId": "UserChanges", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1Changes" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "limit", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + }, + { + "name": "sequence_offset", + "in": "query", + "required": false, + "type": "string", + "format": "uint64" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/email": { + "get": { + "summary": "USER_EMAIL", + "operationId": "GetUserEmail", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserEmail" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "ChangeUserEmail", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserEmail" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UpdateUserEmailRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/email/_resendverification": { + "post": { + "operationId": "ResendEmailVerificationMail", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/mfas": { + "get": { + "summary": "MFA", + "operationId": "GetUserMfas", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1MultiFactors" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/phone": { + "get": { + "summary": "USER_PHONE", + "operationId": "GetUserPhone", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserPhone" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "ChangeUserPhone", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserPhone" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UpdateUserPhoneRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/phone/_resendverification": { + "post": { + "operationId": "ResendPhoneVerificationCode", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "properties": {} + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{id}/profile": { + "get": { + "summary": "USER_PROFILE", + "operationId": "GetUserProfile", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserProfile" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateUserProfile", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserProfile" + } + } + }, + "parameters": [ + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UpdateUserProfileRequest" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{user_id}/grants": { + "post": { + "operationId": "CreateUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserGrantCreate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{user_id}/grants/{id}": { + "get": { + "operationId": "UserGrantByID", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + } + ], + "tags": [ + "ManagementService" + ] + }, + "put": { + "operationId": "UpdateUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserGrantUpdate" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{user_id}/grants/{id}/_deactivate": { + "put": { + "operationId": "DeactivateUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/users/{user_id}/grants/{id}/_reactivate": { + "put": { + "operationId": "ReactivateUserGrant", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/v1UserGrant" + } + } + }, + "parameters": [ + { + "name": "user_id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "id", + "in": "path", + "required": true, + "type": "string" + }, + { + "name": "body", + "in": "body", + "required": true, + "schema": { + "$ref": "#/definitions/v1UserGrantID" + } + } + ], + "tags": [ + "ManagementService" + ] + } + }, + "/validate": { + "get": { + "operationId": "Validate", + "responses": { + "200": { + "description": "A successful response.", + "schema": { + "$ref": "#/definitions/protobufStruct" + } + } + }, + "tags": [ + "ManagementService" + ] + } + } + }, + "definitions": { + "protobufListValue": { + "type": "object", + "properties": { + "values": { + "type": "array", + "items": { + "$ref": "#/definitions/protobufValue" + }, + "description": "Repeated field of dynamically typed values." + } + }, + "description": "`ListValue` is a wrapper around a repeated field of values.\n\nThe JSON representation for `ListValue` is JSON array." + }, + "protobufNullValue": { + "type": "string", + "enum": [ + "NULL_VALUE" + ], + "default": "NULL_VALUE", + "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\n The JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value." + }, + "protobufStruct": { + "type": "object", + "properties": { + "fields": { + "type": "object", + "additionalProperties": { + "$ref": "#/definitions/protobufValue" + }, + "description": "Unordered map of dynamically typed values." + } + }, + "description": "`Struct` represents a structured data value, consisting of fields\nwhich map to dynamically typed values. In some languages, `Struct`\nmight be supported by a native representation. For example, in\nscripting languages like JS a struct is represented as an\nobject. The details of that representation are described together\nwith the proto support for the language.\n\nThe JSON representation for `Struct` is JSON object." + }, + "protobufValue": { + "type": "object", + "properties": { + "null_value": { + "$ref": "#/definitions/protobufNullValue", + "description": "Represents a null value." + }, + "number_value": { + "type": "number", + "format": "double", + "description": "Represents a double value." + }, + "string_value": { + "type": "string", + "description": "Represents a string value." + }, + "bool_value": { + "type": "boolean", + "format": "boolean", + "description": "Represents a boolean value." + }, + "struct_value": { + "$ref": "#/definitions/protobufStruct", + "description": "Represents a structured value." + }, + "list_value": { + "$ref": "#/definitions/protobufListValue", + "description": "Represents a repeated `Value`." + } + }, + "description": "`Value` represents a dynamically typed value which can be either\nnull, a number, a string, a boolean, a recursive struct value, or a\nlist of values. A producer of value is expected to set one of that\nvariants, absence of any variant indicates an error.\n\nThe JSON representation for `Value` is JSON value." + }, + "v1AddOrgMemberRequest": { + "type": "object", + "properties": { + "org_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1AppState": { + "type": "string", + "enum": [ + "APPSTATE_UNSPECIFIED", + "APPSTATE_ACTIVE", + "APPSTATE_INACTIVE" + ], + "default": "APPSTATE_UNSPECIFIED" + }, + "v1Application": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1AppState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "name": { + "type": "string" + }, + "oidc_config": { + "$ref": "#/definitions/v1OIDCConfig" + } + } + }, + "v1ApplicationID": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "project_id": { + "type": "string" + } + } + }, + "v1ApplicationSearchKey": { + "type": "string", + "enum": [ + "APPLICATIONSERACHKEY_UNSPECIFIED", + "APPLICATIONSEARCHKEY_APP_NAME" + ], + "default": "APPLICATIONSERACHKEY_UNSPECIFIED" + }, + "v1ApplicationSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1ApplicationSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1ApplicationSearchRequest": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ApplicationSearchQuery" + } + } + } + }, + "v1ApplicationSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1Application" + } + } + } + }, + "v1ApplicationUpdate": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "id": { + "type": "string" + }, + "name": { + "type": "string" + } + } + }, + "v1AuthGrant": { + "type": "object", + "properties": { + "orgId": { + "type": "string" + }, + "projectId": { + "type": "string" + }, + "userId": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1AuthGrantSearchKey": { + "type": "string", + "enum": [ + "AUTHGRANTSEARCHKEY_UNSPECIFIED", + "AUTHGRANTSEARCHKEY_ORG_ID", + "AUTHGRANTSEARCHKEY_PROJECT_ID", + "AUTHGRANTSEARCHKEY_USER_ID" + ], + "default": "AUTHGRANTSEARCHKEY_UNSPECIFIED" + }, + "v1AuthGrantSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1AuthGrantSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1AuthGrantSearchRequest": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "sorting_column": { + "$ref": "#/definitions/v1AuthGrantSearchKey" + }, + "asc": { + "type": "boolean", + "format": "boolean" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1AuthGrantSearchQuery" + } + } + } + }, + "v1AuthGrantSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1AuthGrant" + } + } + } + }, + "v1Change": { + "type": "object", + "properties": { + "change_date": { + "type": "string", + "format": "date-time" + }, + "event_type": { + "type": "string" + }, + "sequence": { + "type": "string", + "format": "uint64" + }, + "modifier": { + "type": "string" + }, + "data": { + "$ref": "#/definitions/protobufStruct" + } + } + }, + "v1ChangeOrgMemberRequest": { + "type": "object", + "properties": { + "org_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1Changes": { + "type": "object", + "properties": { + "changes": { + "type": "array", + "items": { + "$ref": "#/definitions/v1Change" + } + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + } + } + }, + "v1ClientSecret": { + "type": "object", + "properties": { + "client_secret": { + "type": "string" + } + } + }, + "v1CreateUserRequest": { + "type": "object", + "properties": { + "user_name": { + "type": "string" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "nick_name": { + "type": "string" + }, + "display_name": { + "type": "string" + }, + "preferred_language": { + "type": "string" + }, + "gender": { + "$ref": "#/definitions/v1Gender" + }, + "email": { + "type": "string" + }, + "is_email_verified": { + "type": "boolean", + "format": "boolean" + }, + "phone": { + "type": "string" + }, + "is_phone_verified": { + "type": "boolean", + "format": "boolean" + }, + "country": { + "type": "string" + }, + "locality": { + "type": "string" + }, + "postal_code": { + "type": "string" + }, + "region": { + "type": "string" + }, + "street_address": { + "type": "string" + }, + "password": { + "type": "string" + } + } + }, + "v1Gender": { + "type": "string", + "enum": [ + "GENDER_UNSPECIFIED", + "GENDER_FEMALE", + "GENDER_MALE", + "GENDER_DIVERSE" + ], + "default": "GENDER_UNSPECIFIED" + }, + "v1MFAState": { + "type": "string", + "enum": [ + "MFASTATE_UNSPECIFIED", + "MFASTATE_NOT_READY", + "MFASTATE_READY", + "MFASTATE_REMOVED" + ], + "default": "MFASTATE_UNSPECIFIED" + }, + "v1MfaType": { + "type": "string", + "enum": [ + "MFATYPE_UNSPECIFIED", + "MFATYPE_SMS", + "MFATYPE_OTP" + ], + "default": "MFATYPE_UNSPECIFIED" + }, + "v1MultiFactor": { + "type": "object", + "properties": { + "type": { + "$ref": "#/definitions/v1MfaType" + }, + "state": { + "$ref": "#/definitions/v1MFAState" + } + } + }, + "v1MultiFactors": { + "type": "object", + "properties": { + "mfas": { + "type": "array", + "items": { + "$ref": "#/definitions/v1MultiFactor" + } + } + } + }, + "v1NotificationType": { + "type": "string", + "enum": [ + "NOTIFICATIONTYPE_EMAIL", + "NOTIFICATIONTYPE_SMS" + ], + "default": "NOTIFICATIONTYPE_EMAIL" + }, + "v1OIDCApplicationCreate": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "redirect_uris": { + "type": "array", + "items": { + "type": "string" + } + }, + "response_types": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OIDCResponseType" + } + }, + "grant_types": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OIDCGrantType" + } + }, + "application_type": { + "$ref": "#/definitions/v1OIDCApplicationType" + }, + "auth_method_type": { + "$ref": "#/definitions/v1OIDCAuthMethodType" + }, + "post_logout_redirect_uris": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1OIDCApplicationType": { + "type": "string", + "enum": [ + "OIDCAPPLICATIONTYPE_WEB", + "OIDCAPPLICATIONTYPE_USER_AGENT", + "OIDCAPPLICATIONTYPE_NATIVE" + ], + "default": "OIDCAPPLICATIONTYPE_WEB" + }, + "v1OIDCAuthMethodType": { + "type": "string", + "enum": [ + "OIDCAUTHMETHODTYPE_BASIC", + "OIDCAUTHMETHODTYPE_POST", + "OIDCAUTHMETHODTYPE_NONE" + ], + "default": "OIDCAUTHMETHODTYPE_BASIC" + }, + "v1OIDCConfig": { + "type": "object", + "properties": { + "redirect_uris": { + "type": "array", + "items": { + "type": "string" + } + }, + "response_types": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OIDCResponseType" + } + }, + "grant_types": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OIDCGrantType" + } + }, + "application_type": { + "$ref": "#/definitions/v1OIDCApplicationType" + }, + "client_id": { + "type": "string" + }, + "client_secret": { + "type": "string" + }, + "auth_method_type": { + "$ref": "#/definitions/v1OIDCAuthMethodType" + }, + "post_logout_redirect_uris": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1OIDCConfigUpdate": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "application_id": { + "type": "string" + }, + "redirect_uris": { + "type": "array", + "items": { + "type": "string" + } + }, + "response_types": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OIDCResponseType" + } + }, + "grant_types": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OIDCGrantType" + } + }, + "application_type": { + "$ref": "#/definitions/v1OIDCApplicationType" + }, + "auth_method_type": { + "$ref": "#/definitions/v1OIDCAuthMethodType" + }, + "post_logout_redirect_uris": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1OIDCGrantType": { + "type": "string", + "enum": [ + "OIDCGRANTTYPE_AUTHORIZATION_CODE", + "OIDCGRANTTYPE_IMPLICIT", + "OIDCGRANTTYPE_REFRESH_TOKEN" + ], + "default": "OIDCGRANTTYPE_AUTHORIZATION_CODE" + }, + "v1OIDCResponseType": { + "type": "string", + "enum": [ + "OIDCRESPONSETYPE_CODE", + "OIDCRESPONSETYPE_ID_TOKEN", + "OIDCRESPONSETYPE_TOKEN_ID_TOKEN" + ], + "default": "OIDCRESPONSETYPE_CODE" + }, + "v1Org": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1OrgState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "name": { + "type": "string" + }, + "domain": { + "type": "string" + } + } + }, + "v1OrgID": { + "type": "object", + "properties": { + "id": { + "type": "string" + } + } + }, + "v1OrgMember": { + "type": "object", + "properties": { + "user_id": { + "type": "string" + }, + "user_name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "creation_date": { + "type": "string", + "format": "date-time" + } + } + }, + "v1OrgMemberRoles": { + "type": "object", + "properties": { + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1OrgMemberSearchKey": { + "type": "string", + "enum": [ + "ORGMEMBERSEARCHKEY_UNSPECIFIED", + "ORGMEMBERSEARCHKEY_FIRST_NAME", + "ORGMEMBERSEARCHKEY_LAST_NAME", + "ORGMEMBERSEARCHKEY_EMAIL", + "ORGMEMBERSEARCHKEY_USER_ID" + ], + "default": "ORGMEMBERSEARCHKEY_UNSPECIFIED" + }, + "v1OrgMemberSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1OrgMemberSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1OrgMemberSearchRequest": { + "type": "object", + "properties": { + "org_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OrgMemberSearchQuery" + } + } + } + }, + "v1OrgMemberSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1OrgMember" + } + } + } + }, + "v1OrgState": { + "type": "string", + "enum": [ + "ORGSTATE_UNSPECIFIED", + "ORGSTATE_ACTIVE", + "ORGSTATE_INACTIVE" + ], + "default": "ORGSTATE_UNSPECIFIED" + }, + "v1PasswordAgePolicy": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "description": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1PolicyState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "max_age_days": { + "type": "string", + "format": "uint64" + }, + "expire_warn_days": { + "type": "string", + "format": "uint64" + } + } + }, + "v1PasswordAgePolicyCreate": { + "type": "object", + "properties": { + "description": { + "type": "string" + }, + "max_age_days": { + "type": "string", + "format": "uint64" + }, + "expire_warn_days": { + "type": "string", + "format": "uint64" + } + } + }, + "v1PasswordAgePolicyUpdate": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "description": { + "type": "string" + }, + "max_age_days": { + "type": "string", + "format": "uint64" + }, + "expire_warn_days": { + "type": "string", + "format": "uint64" + } + } + }, + "v1PasswordComplexityPolicy": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "description": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1PolicyState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "min_length": { + "type": "string", + "format": "uint64" + }, + "has_lowercase": { + "type": "boolean", + "format": "boolean" + }, + "has_uppercase": { + "type": "boolean", + "format": "boolean" + }, + "has_number": { + "type": "boolean", + "format": "boolean" + }, + "has_symbol": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1PasswordComplexityPolicyCreate": { + "type": "object", + "properties": { + "description": { + "type": "string" + }, + "min_length": { + "type": "string", + "format": "uint64" + }, + "has_lowercase": { + "type": "boolean", + "format": "boolean" + }, + "has_uppercase": { + "type": "boolean", + "format": "boolean" + }, + "has_number": { + "type": "boolean", + "format": "boolean" + }, + "has_symbol": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1PasswordComplexityPolicyUpdate": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "description": { + "type": "string" + }, + "min_length": { + "type": "string", + "format": "uint64" + }, + "has_lowercase": { + "type": "boolean", + "format": "boolean" + }, + "has_uppercase": { + "type": "boolean", + "format": "boolean" + }, + "has_number": { + "type": "boolean", + "format": "boolean" + }, + "has_symbol": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1PasswordLockoutPolicy": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "description": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1PolicyState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "max_attempts": { + "type": "string", + "format": "uint64" + }, + "show_lock_out_failures": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1PasswordLockoutPolicyCreate": { + "type": "object", + "properties": { + "description": { + "type": "string" + }, + "max_attempts": { + "type": "string", + "format": "uint64" + }, + "show_lock_out_failures": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1PasswordLockoutPolicyUpdate": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "description": { + "type": "string" + }, + "max_attempts": { + "type": "string", + "format": "uint64" + }, + "show_lock_out_failures": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1PasswordRequest": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "password": { + "type": "string" + } + } + }, + "v1PolicyState": { + "type": "string", + "enum": [ + "POLICYSTATE_UNSPECIFIED", + "POLICYSTATE_ACTIVE", + "POLICYSTATE_INACTIVE", + "POLICYSTATE_DELETED" + ], + "default": "POLICYSTATE_UNSPECIFIED" + }, + "v1Project": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1ProjectState" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "type": { + "$ref": "#/definitions/v1ProjectType" + }, + "resource_owner": { + "type": "string" + }, + "org_id": { + "type": "string" + }, + "org_name": { + "type": "string" + }, + "org_domain": { + "type": "string" + }, + "grant_id": { + "type": "string" + } + } + }, + "v1ProjectCreateRequest": { + "type": "object", + "properties": { + "name": { + "type": "string" + } + } + }, + "v1ProjectGrant": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "project_id": { + "type": "string" + }, + "granted_org_id": { + "type": "string" + }, + "granted_org_name": { + "type": "string" + }, + "granted_org_domain": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + }, + "state": { + "$ref": "#/definitions/v1ProjectGrantState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "project_name": { + "type": "string" + } + } + }, + "v1ProjectGrantCreate": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "granted_org_id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectGrantID": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "id": { + "type": "string" + } + } + }, + "v1ProjectGrantMember": { + "type": "object", + "properties": { + "user_id": { + "type": "string" + }, + "user_name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "creation_date": { + "type": "string", + "format": "date-time" + } + } + }, + "v1ProjectGrantMemberAdd": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "grant_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectGrantMemberChange": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "grant_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectGrantMemberRoles": { + "type": "object", + "properties": { + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectGrantMemberSearchKey": { + "type": "string", + "enum": [ + "PROJECTGRANTMEMBERSEARCHKEY_UNSPECIFIED", + "PROJECTGRANTMEMBERSEARCHKEY_FIRST_NAME", + "PROJECTGRANTMEMBERSEARCHKEY_LAST_NAME", + "PROJECTGRANTMEMBERSEARCHKEY_EMAIL", + "PROJECTGRANTMEMBERSEARCHKEY_USER_ID" + ], + "default": "PROJECTGRANTMEMBERSEARCHKEY_UNSPECIFIED" + }, + "v1ProjectGrantMemberSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1ProjectGrantMemberSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1ProjectGrantMemberSearchRequest": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "grant_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectGrantMemberSearchQuery" + } + } + } + }, + "v1ProjectGrantMemberSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectGrantMember" + } + } + } + }, + "v1ProjectGrantSearchRequest": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + } + } + }, + "v1ProjectGrantSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectGrant" + } + } + } + }, + "v1ProjectGrantState": { + "type": "string", + "enum": [ + "PROJECTGRANTSTATE_UNSPECIFIED", + "PROJECTGRANTSTATE_ACTIVE", + "PROJECTGRANTSTATE_INACTIVE" + ], + "default": "PROJECTGRANTSTATE_UNSPECIFIED" + }, + "v1ProjectGrantUpdate": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectGrantUserGrantCreate": { + "type": "object", + "properties": { + "user_id": { + "type": "string" + }, + "org_id": { + "type": "string" + }, + "project_grant_id": { + "type": "string" + }, + "project_id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectGrantUserGrantID": { + "type": "object", + "properties": { + "project_grant_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "id": { + "type": "string" + } + } + }, + "v1ProjectGrantUserGrantSearchRequest": { + "type": "object", + "properties": { + "project_grant_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1UserGrantSearchQuery" + } + } + } + }, + "v1ProjectGrantUserGrantUpdate": { + "type": "object", + "properties": { + "project_grant_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectID": { + "type": "object", + "properties": { + "id": { + "type": "string" + } + } + }, + "v1ProjectMember": { + "type": "object", + "properties": { + "user_id": { + "type": "string" + }, + "user_name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "creation_date": { + "type": "string", + "format": "date-time" + } + } + }, + "v1ProjectMemberAdd": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectMemberChange": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectMemberRoles": { + "type": "object", + "properties": { + "roles": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1ProjectMemberSearchKey": { + "type": "string", + "enum": [ + "PROJECTMEMBERSEARCHKEY_UNSPECIFIED", + "PROJECTMEMBERSEARCHKEY_FIRST_NAME", + "PROJECTMEMBERSEARCHKEY_LAST_NAME", + "PROJECTMEMBERSEARCHKEY_EMAIL", + "PROJECTMEMBERSEARCHKEY_USER_ID" + ], + "default": "PROJECTMEMBERSEARCHKEY_UNSPECIFIED" + }, + "v1ProjectMemberSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1ProjectMemberSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1ProjectMemberSearchRequest": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectMemberSearchQuery" + } + } + } + }, + "v1ProjectMemberSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectMember" + } + } + } + }, + "v1ProjectRole": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "display_name": { + "type": "string" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "group": { + "type": "string" + } + } + }, + "v1ProjectRoleAdd": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string" + }, + "display_name": { + "type": "string" + }, + "group": { + "type": "string" + } + } + }, + "v1ProjectRoleSearchKey": { + "type": "string", + "enum": [ + "PROJECTROLESEARCHKEY_UNSPECIFIED", + "PROJECTROLESEARCHKEY_NAME", + "PROJECTROLESEARCHKEY_DISPLAY_NAME" + ], + "default": "PROJECTROLESEARCHKEY_UNSPECIFIED" + }, + "v1ProjectRoleSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1ProjectRoleSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1ProjectRoleSearchRequest": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectRoleSearchQuery" + } + } + } + }, + "v1ProjectRoleSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectRole" + } + } + } + }, + "v1ProjectSearchKey": { + "type": "string", + "enum": [ + "PROJECTSEARCHKEY_UNSPECIFIED", + "PROJECTSEARCHKEY_PROJECT_NAME" + ], + "default": "PROJECTSEARCHKEY_UNSPECIFIED" + }, + "v1ProjectSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1ProjectSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1ProjectSearchRequest": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1ProjectSearchQuery" + } + } + } + }, + "v1ProjectSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1Project" + } + } + } + }, + "v1ProjectState": { + "type": "string", + "enum": [ + "PROJECTSTATE_UNSPECIFIED", + "PROJECTSTATE_ACTIVE", + "PROJECTSSTATE_INACTIVE" + ], + "default": "PROJECTSTATE_UNSPECIFIED" + }, + "v1ProjectType": { + "type": "string", + "enum": [ + "PROJECTTYPE_UNKNOWN", + "PROJECTTYPE_SELF", + "PROJECTTYPE_GRANTED" + ], + "default": "PROJECTTYPE_UNKNOWN" + }, + "v1ProjectUpdateRequest": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "name": { + "type": "string" + } + } + }, + "v1ProjectUserGrantID": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "id": { + "type": "string" + } + } + }, + "v1ProjectUserGrantSearchRequest": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1UserGrantSearchQuery" + } + } + } + }, + "v1ProjectUserGrantUpdate": { + "type": "object", + "properties": { + "project_id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1SearchMethod": { + "type": "string", + "enum": [ + "SEARCHMETHOD_EQUALS", + "SEARCHMETHOD_STARTS_WITH", + "SEARCHMETHOD_CONTAINS" + ], + "default": "SEARCHMETHOD_EQUALS" + }, + "v1SetPasswordNotificationRequest": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "type": { + "$ref": "#/definitions/v1NotificationType" + } + } + }, + "v1UniqueUserResponse": { + "type": "object", + "properties": { + "is_unique": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1UpdateUserAddressRequest": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "country": { + "type": "string" + }, + "locality": { + "type": "string" + }, + "postal_code": { + "type": "string" + }, + "region": { + "type": "string" + }, + "street_address": { + "type": "string" + } + } + }, + "v1UpdateUserEmailRequest": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "email": { + "type": "string" + }, + "is_email_verified": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1UpdateUserPhoneRequest": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "phone": { + "type": "string" + }, + "is_phone_verified": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1UpdateUserProfileRequest": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "nick_name": { + "type": "string" + }, + "display_name": { + "type": "string" + }, + "preferred_language": { + "type": "string" + }, + "gender": { + "$ref": "#/definitions/v1Gender" + } + } + }, + "v1User": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1UserState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "last_login": { + "type": "string", + "format": "date-time" + }, + "password_changed": { + "type": "string", + "format": "date-time" + }, + "user_name": { + "type": "string" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "display_name": { + "type": "string" + }, + "nick_name": { + "type": "string" + }, + "preferred_language": { + "type": "string" + }, + "gender": { + "$ref": "#/definitions/v1Gender" + }, + "email": { + "type": "string" + }, + "is_email_verified": { + "type": "boolean", + "format": "boolean" + }, + "phone": { + "type": "string" + }, + "is_phone_verified": { + "type": "boolean", + "format": "boolean" + }, + "country": { + "type": "string" + }, + "locality": { + "type": "string" + }, + "postal_code": { + "type": "string" + }, + "region": { + "type": "string" + }, + "street_address": { + "type": "string" + } + } + }, + "v1UserAddress": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "country": { + "type": "string" + }, + "locality": { + "type": "string" + }, + "postal_code": { + "type": "string" + }, + "region": { + "type": "string" + }, + "street_address": { + "type": "string" + } + } + }, + "v1UserEmail": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "email": { + "type": "string" + }, + "is_email_verified": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1UserGrant": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "user_id": { + "type": "string" + }, + "org_id": { + "type": "string" + }, + "project_id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + }, + "state": { + "$ref": "#/definitions/v1UserGrantState" + }, + "creation_date": { + "type": "string", + "format": "date-time" + }, + "change_date": { + "type": "string", + "format": "date-time" + }, + "user_name": { + "type": "string" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "email": { + "type": "string" + }, + "org_name": { + "type": "string" + }, + "org_domain": { + "type": "string" + }, + "project_name": { + "type": "string" + } + } + }, + "v1UserGrantCreate": { + "type": "object", + "properties": { + "user_id": { + "type": "string" + }, + "org_id": { + "type": "string" + }, + "project_id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1UserGrantID": { + "type": "object", + "properties": { + "user_id": { + "type": "string" + }, + "id": { + "type": "string" + } + } + }, + "v1UserGrantSearchKey": { + "type": "string", + "enum": [ + "USERGRANTSEARCHKEY_UNSPECIFIED", + "USERGRANTSEARCHKEY_PROJECT_ID", + "USERGRANTSEARCHKEY_USER_ID", + "USERGRANTSEARCHKEY_ORG_ID" + ], + "default": "USERGRANTSEARCHKEY_UNSPECIFIED" + }, + "v1UserGrantSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1UserGrantSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1UserGrantSearchRequest": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1UserGrantSearchQuery" + } + } + } + }, + "v1UserGrantSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1UserGrant" + } + } + } + }, + "v1UserGrantState": { + "type": "string", + "enum": [ + "USERGRANTSTATE_UNSPECIFIED", + "USERGRANTSTATE_ACTIVE", + "USERGRANTSTATE_INACTIVE" + ], + "default": "USERGRANTSTATE_UNSPECIFIED" + }, + "v1UserGrantUpdate": { + "type": "object", + "properties": { + "user_id": { + "type": "string" + }, + "id": { + "type": "string" + }, + "role_names": { + "type": "array", + "items": { + "type": "string" + } + } + } + }, + "v1UserID": { + "type": "object", + "properties": { + "id": { + "type": "string" + } + } + }, + "v1UserPhone": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "phone": { + "type": "string" + }, + "is_phone_verified": { + "type": "boolean", + "format": "boolean" + } + } + }, + "v1UserProfile": { + "type": "object", + "properties": { + "id": { + "type": "string" + }, + "state": { + "$ref": "#/definitions/v1UserState" + }, + "first_name": { + "type": "string" + }, + "last_name": { + "type": "string" + }, + "nick_name": { + "type": "string" + }, + "display_name": { + "type": "string" + }, + "preferred_language": { + "type": "string" + }, + "gender": { + "$ref": "#/definitions/v1Gender" + }, + "user_name": { + "type": "string" + } + } + }, + "v1UserSearchKey": { + "type": "string", + "enum": [ + "USERSEARCHKEY_UNSPECIFIED", + "USERSEARCHKEY_USER_NAME", + "USERSEARCHKEY_FIRST_NAME", + "USERSEARCHKEY_LAST_NAME", + "USERSEARCHKEY_NICK_NAME", + "USERSEARCHKEY_DISPLAY_NAME", + "USERSEARCHKEY_EMAIL", + "USERSEARCHKEY_STATE" + ], + "default": "USERSEARCHKEY_UNSPECIFIED" + }, + "v1UserSearchQuery": { + "type": "object", + "properties": { + "key": { + "$ref": "#/definitions/v1UserSearchKey" + }, + "method": { + "$ref": "#/definitions/v1SearchMethod" + }, + "value": { + "type": "string" + } + } + }, + "v1UserSearchRequest": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "sorting_column": { + "$ref": "#/definitions/v1UserSearchKey" + }, + "asc": { + "type": "boolean", + "format": "boolean" + }, + "queries": { + "type": "array", + "items": { + "$ref": "#/definitions/v1UserSearchQuery" + } + } + } + }, + "v1UserSearchResponse": { + "type": "object", + "properties": { + "offset": { + "type": "string", + "format": "uint64" + }, + "limit": { + "type": "string", + "format": "uint64" + }, + "total_result": { + "type": "string", + "format": "uint64" + }, + "result": { + "type": "array", + "items": { + "$ref": "#/definitions/v1User" + } + } + } + }, + "v1UserState": { + "type": "string", + "enum": [ + "USERSTATE_UNSPECIFIED", + "USERSTATE_ACTIVE", + "USERSTATE_INACTIVE", + "USERSTATE_DELETED", + "USERSTATE_LOCKED", + "USERSTATE_SUSPEND", + "USERSTATE_INITIAL" + ], + "default": "USERSTATE_UNSPECIFIED" + } + } +} diff --git a/pkg/management/api/grpc/mock/management.proto.mock.go b/pkg/management/api/grpc/mock/management.proto.mock.go new file mode 100644 index 0000000000..6b1afffa8c --- /dev/null +++ b/pkg/management/api/grpc/mock/management.proto.mock.go @@ -0,0 +1,2118 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/caos/citadel/management/api/grpc (interfaces: ManagementServiceClient) + +// Package api is a generated GoMock package. +package api + +import ( + context "context" + grpc "github.com/caos/citadel/management/api/grpc" + gomock "github.com/golang/mock/gomock" + empty "github.com/golang/protobuf/ptypes/empty" + struct0 "github.com/golang/protobuf/ptypes/struct" + grpc0 "google.golang.org/grpc" + 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 +} + +// AddOrgMember mocks base method +func (m *MockManagementServiceClient) AddOrgMember(arg0 context.Context, arg1 *grpc.AddOrgMemberRequest, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AddOrgMember", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddOrgMember indicates an expected call of AddOrgMember +func (mr *MockManagementServiceClientMockRecorder) AddOrgMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrgMember", reflect.TypeOf((*MockManagementServiceClient)(nil).AddOrgMember), varargs...) +} + +// AddProjectGrantMember mocks base method +func (m *MockManagementServiceClient) AddProjectGrantMember(arg0 context.Context, arg1 *grpc.ProjectGrantMemberAdd, arg2 ...grpc0.CallOption) (*empty.Empty, 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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddProjectGrantMember indicates an expected call of AddProjectGrantMember +func (mr *MockManagementServiceClientMockRecorder) AddProjectGrantMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProjectGrantMember", reflect.TypeOf((*MockManagementServiceClient)(nil).AddProjectGrantMember), varargs...) +} + +// AddProjectMember mocks base method +func (m *MockManagementServiceClient) AddProjectMember(arg0 context.Context, arg1 *grpc.ProjectMemberAdd, arg2 ...grpc0.CallOption) (*empty.Empty, 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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddProjectMember indicates an expected call of AddProjectMember +func (mr *MockManagementServiceClientMockRecorder) AddProjectMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProjectMember", reflect.TypeOf((*MockManagementServiceClient)(nil).AddProjectMember), varargs...) +} + +// AddProjectRole mocks base method +func (m *MockManagementServiceClient) AddProjectRole(arg0 context.Context, arg1 *grpc.ProjectRoleAdd, arg2 ...grpc0.CallOption) (*empty.Empty, 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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddProjectRole indicates an expected call of AddProjectRole +func (mr *MockManagementServiceClientMockRecorder) AddProjectRole(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddProjectRole", reflect.TypeOf((*MockManagementServiceClient)(nil).AddProjectRole), varargs...) +} + +// ApplicationByID mocks base method +func (m *MockManagementServiceClient) ApplicationByID(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.Application, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ApplicationByID", varargs...) + ret0, _ := ret[0].(*grpc.Application) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ApplicationByID indicates an expected call of ApplicationByID +func (mr *MockManagementServiceClientMockRecorder) ApplicationByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplicationByID", reflect.TypeOf((*MockManagementServiceClient)(nil).ApplicationByID), varargs...) +} + +// ApplicationChanges mocks base method +func (m *MockManagementServiceClient) ApplicationChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ApplicationChanges", varargs...) + ret0, _ := ret[0].(*grpc.Changes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ApplicationChanges indicates an expected call of ApplicationChanges +func (mr *MockManagementServiceClientMockRecorder) ApplicationChanges(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplicationChanges", reflect.TypeOf((*MockManagementServiceClient)(nil).ApplicationChanges), varargs...) +} + +// ChangeOrgMember mocks base method +func (m *MockManagementServiceClient) ChangeOrgMember(arg0 context.Context, arg1 *grpc.ChangeOrgMemberRequest, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeOrgMember", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeOrgMember indicates an expected call of ChangeOrgMember +func (mr *MockManagementServiceClientMockRecorder) ChangeOrgMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeOrgMember", reflect.TypeOf((*MockManagementServiceClient)(nil).ChangeOrgMember), varargs...) +} + +// ChangeProjectGrantMember mocks base method +func (m *MockManagementServiceClient) ChangeProjectGrantMember(arg0 context.Context, arg1 *grpc.ProjectGrantMemberChange, arg2 ...grpc0.CallOption) (*empty.Empty, 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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeProjectGrantMember indicates an expected call of ChangeProjectGrantMember +func (mr *MockManagementServiceClientMockRecorder) ChangeProjectGrantMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeProjectGrantMember", reflect.TypeOf((*MockManagementServiceClient)(nil).ChangeProjectGrantMember), varargs...) +} + +// ChangeProjectMember mocks base method +func (m *MockManagementServiceClient) ChangeProjectMember(arg0 context.Context, arg1 *grpc.ProjectMemberChange, arg2 ...grpc0.CallOption) (*empty.Empty, 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].(*empty.Empty) + 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...) +} + +// ChangeUserEmail mocks base method +func (m *MockManagementServiceClient) ChangeUserEmail(arg0 context.Context, arg1 *grpc.UpdateUserEmailRequest, arg2 ...grpc0.CallOption) (*grpc.UserEmail, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeUserEmail", varargs...) + ret0, _ := ret[0].(*grpc.UserEmail) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeUserEmail indicates an expected call of ChangeUserEmail +func (mr *MockManagementServiceClientMockRecorder) ChangeUserEmail(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeUserEmail", reflect.TypeOf((*MockManagementServiceClient)(nil).ChangeUserEmail), varargs...) +} + +// ChangeUserPhone mocks base method +func (m *MockManagementServiceClient) ChangeUserPhone(arg0 context.Context, arg1 *grpc.UpdateUserPhoneRequest, arg2 ...grpc0.CallOption) (*grpc.UserPhone, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangeUserPhone", varargs...) + ret0, _ := ret[0].(*grpc.UserPhone) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangeUserPhone indicates an expected call of ChangeUserPhone +func (mr *MockManagementServiceClientMockRecorder) ChangeUserPhone(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeUserPhone", reflect.TypeOf((*MockManagementServiceClient)(nil).ChangeUserPhone), varargs...) +} + +// CreateOIDCApplication mocks base method +func (m *MockManagementServiceClient) CreateOIDCApplication(arg0 context.Context, arg1 *grpc.OIDCApplicationCreate, arg2 ...grpc0.CallOption) (*grpc.Application, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateOIDCApplication", varargs...) + ret0, _ := ret[0].(*grpc.Application) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOIDCApplication indicates an expected call of CreateOIDCApplication +func (mr *MockManagementServiceClientMockRecorder) CreateOIDCApplication(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOIDCApplication", reflect.TypeOf((*MockManagementServiceClient)(nil).CreateOIDCApplication), varargs...) +} + +// CreatePasswordAgePolicy mocks base method +func (m *MockManagementServiceClient) CreatePasswordAgePolicy(arg0 context.Context, arg1 *grpc.PasswordAgePolicyCreate, arg2 ...grpc0.CallOption) (*grpc.PasswordAgePolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePasswordAgePolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordAgePolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePasswordAgePolicy indicates an expected call of CreatePasswordAgePolicy +func (mr *MockManagementServiceClientMockRecorder) CreatePasswordAgePolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePasswordAgePolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).CreatePasswordAgePolicy), varargs...) +} + +// CreatePasswordComplexityPolicy mocks base method +func (m *MockManagementServiceClient) CreatePasswordComplexityPolicy(arg0 context.Context, arg1 *grpc.PasswordComplexityPolicyCreate, arg2 ...grpc0.CallOption) (*grpc.PasswordComplexityPolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePasswordComplexityPolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordComplexityPolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePasswordComplexityPolicy indicates an expected call of CreatePasswordComplexityPolicy +func (mr *MockManagementServiceClientMockRecorder) CreatePasswordComplexityPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePasswordComplexityPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).CreatePasswordComplexityPolicy), varargs...) +} + +// CreatePasswordLockoutPolicy mocks base method +func (m *MockManagementServiceClient) CreatePasswordLockoutPolicy(arg0 context.Context, arg1 *grpc.PasswordLockoutPolicyCreate, arg2 ...grpc0.CallOption) (*grpc.PasswordLockoutPolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreatePasswordLockoutPolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordLockoutPolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePasswordLockoutPolicy indicates an expected call of CreatePasswordLockoutPolicy +func (mr *MockManagementServiceClientMockRecorder) CreatePasswordLockoutPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePasswordLockoutPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).CreatePasswordLockoutPolicy), varargs...) +} + +// CreateProject mocks base method +func (m *MockManagementServiceClient) CreateProject(arg0 context.Context, arg1 *grpc.ProjectCreateRequest, arg2 ...grpc0.CallOption) (*grpc.Project, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateProject", varargs...) + ret0, _ := ret[0].(*grpc.Project) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateProject indicates an expected call of CreateProject +func (mr *MockManagementServiceClientMockRecorder) CreateProject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProject", reflect.TypeOf((*MockManagementServiceClient)(nil).CreateProject), varargs...) +} + +// CreateProjectGrant mocks base method +func (m *MockManagementServiceClient) CreateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantCreate, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateProjectGrant", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateProjectGrant indicates an expected call of CreateProjectGrant +func (mr *MockManagementServiceClientMockRecorder) CreateProjectGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProjectGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).CreateProjectGrant), varargs...) +} + +// CreateProjectGrantUserGrant mocks base method +func (m *MockManagementServiceClient) CreateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantCreate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateProjectGrantUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateProjectGrantUserGrant indicates an expected call of CreateProjectGrantUserGrant +func (mr *MockManagementServiceClientMockRecorder) CreateProjectGrantUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProjectGrantUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).CreateProjectGrantUserGrant), varargs...) +} + +// CreateProjectUserGrant mocks base method +func (m *MockManagementServiceClient) CreateProjectUserGrant(arg0 context.Context, arg1 *grpc.UserGrantCreate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateProjectUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateProjectUserGrant indicates an expected call of CreateProjectUserGrant +func (mr *MockManagementServiceClientMockRecorder) CreateProjectUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProjectUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).CreateProjectUserGrant), varargs...) +} + +// CreateUser mocks base method +func (m *MockManagementServiceClient) CreateUser(arg0 context.Context, arg1 *grpc.CreateUserRequest, arg2 ...grpc0.CallOption) (*grpc.User, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateUser", varargs...) + ret0, _ := ret[0].(*grpc.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateUser indicates an expected call of CreateUser +func (mr *MockManagementServiceClientMockRecorder) CreateUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUser", reflect.TypeOf((*MockManagementServiceClient)(nil).CreateUser), varargs...) +} + +// CreateUserGrant mocks base method +func (m *MockManagementServiceClient) CreateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantCreate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateUserGrant indicates an expected call of CreateUserGrant +func (mr *MockManagementServiceClientMockRecorder) CreateUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).CreateUserGrant), varargs...) +} + +// DeactivateApplication mocks base method +func (m *MockManagementServiceClient) DeactivateApplication(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.Application, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateApplication", varargs...) + ret0, _ := ret[0].(*grpc.Application) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateApplication indicates an expected call of DeactivateApplication +func (mr *MockManagementServiceClientMockRecorder) DeactivateApplication(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateApplication", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateApplication), varargs...) +} + +// DeactivateOrg mocks base method +func (m *MockManagementServiceClient) DeactivateOrg(arg0 context.Context, arg1 *grpc.OrgID, arg2 ...grpc0.CallOption) (*grpc.Org, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateOrg", varargs...) + ret0, _ := ret[0].(*grpc.Org) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateOrg indicates an expected call of DeactivateOrg +func (mr *MockManagementServiceClientMockRecorder) DeactivateOrg(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateOrg", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateOrg), varargs...) +} + +// DeactivateProject mocks base method +func (m *MockManagementServiceClient) DeactivateProject(arg0 context.Context, arg1 *grpc.ProjectID, arg2 ...grpc0.CallOption) (*grpc.Project, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateProject", varargs...) + ret0, _ := ret[0].(*grpc.Project) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateProject indicates an expected call of DeactivateProject +func (mr *MockManagementServiceClientMockRecorder) DeactivateProject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateProject", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateProject), varargs...) +} + +// DeactivateProjectGrant mocks base method +func (m *MockManagementServiceClient) DeactivateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateProjectGrant", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateProjectGrant indicates an expected call of DeactivateProjectGrant +func (mr *MockManagementServiceClientMockRecorder) DeactivateProjectGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateProjectGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateProjectGrant), varargs...) +} + +// DeactivateProjectGrantUserGrant mocks base method +func (m *MockManagementServiceClient) DeactivateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateProjectGrantUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateProjectGrantUserGrant indicates an expected call of DeactivateProjectGrantUserGrant +func (mr *MockManagementServiceClientMockRecorder) DeactivateProjectGrantUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateProjectGrantUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateProjectGrantUserGrant), varargs...) +} + +// DeactivateProjectUserGrant mocks base method +func (m *MockManagementServiceClient) DeactivateProjectUserGrant(arg0 context.Context, arg1 *grpc.ProjectUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateProjectUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateProjectUserGrant indicates an expected call of DeactivateProjectUserGrant +func (mr *MockManagementServiceClientMockRecorder) DeactivateProjectUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateProjectUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateProjectUserGrant), varargs...) +} + +// DeactivateUser mocks base method +func (m *MockManagementServiceClient) DeactivateUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateUser", varargs...) + ret0, _ := ret[0].(*grpc.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateUser indicates an expected call of DeactivateUser +func (mr *MockManagementServiceClientMockRecorder) DeactivateUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateUser", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateUser), varargs...) +} + +// DeactivateUserGrant mocks base method +func (m *MockManagementServiceClient) DeactivateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeactivateUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeactivateUserGrant indicates an expected call of DeactivateUserGrant +func (mr *MockManagementServiceClientMockRecorder) DeactivateUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).DeactivateUserGrant), varargs...) +} + +// DeletePasswordAgePolicy mocks base method +func (m *MockManagementServiceClient) DeletePasswordAgePolicy(arg0 context.Context, arg1 *grpc.PasswordAgePolicyID, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePasswordAgePolicy", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePasswordAgePolicy indicates an expected call of DeletePasswordAgePolicy +func (mr *MockManagementServiceClientMockRecorder) DeletePasswordAgePolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePasswordAgePolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).DeletePasswordAgePolicy), varargs...) +} + +// DeletePasswordComplexityPolicy mocks base method +func (m *MockManagementServiceClient) DeletePasswordComplexityPolicy(arg0 context.Context, arg1 *grpc.PasswordComplexityPolicyID, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePasswordComplexityPolicy", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePasswordComplexityPolicy indicates an expected call of DeletePasswordComplexityPolicy +func (mr *MockManagementServiceClientMockRecorder) DeletePasswordComplexityPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePasswordComplexityPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).DeletePasswordComplexityPolicy), varargs...) +} + +// DeletePasswordLockoutPolicy mocks base method +func (m *MockManagementServiceClient) DeletePasswordLockoutPolicy(arg0 context.Context, arg1 *grpc.PasswordLockoutPolicyID, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePasswordLockoutPolicy", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePasswordLockoutPolicy indicates an expected call of DeletePasswordLockoutPolicy +func (mr *MockManagementServiceClientMockRecorder) DeletePasswordLockoutPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePasswordLockoutPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).DeletePasswordLockoutPolicy), varargs...) +} + +// DeleteUser mocks base method +func (m *MockManagementServiceClient) DeleteUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*empty.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].(*empty.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...) +} + +// GetGrantedProjectGrantByID mocks base method +func (m *MockManagementServiceClient) GetGrantedProjectGrantByID(arg0 context.Context, arg1 *grpc.GrantedGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetGrantedProjectGrantByID", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetGrantedProjectGrantByID indicates an expected call of GetGrantedProjectGrantByID +func (mr *MockManagementServiceClientMockRecorder) GetGrantedProjectGrantByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGrantedProjectGrantByID", reflect.TypeOf((*MockManagementServiceClient)(nil).GetGrantedProjectGrantByID), varargs...) +} + +// GetOrgByDomainGlobal mocks base method +func (m *MockManagementServiceClient) GetOrgByDomainGlobal(arg0 context.Context, arg1 *grpc.OrgDomain, arg2 ...grpc0.CallOption) (*grpc.Org, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOrgByDomainGlobal", varargs...) + ret0, _ := ret[0].(*grpc.Org) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrgByDomainGlobal indicates an expected call of GetOrgByDomainGlobal +func (mr *MockManagementServiceClientMockRecorder) GetOrgByDomainGlobal(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgByDomainGlobal", reflect.TypeOf((*MockManagementServiceClient)(nil).GetOrgByDomainGlobal), varargs...) +} + +// GetOrgByID mocks base method +func (m *MockManagementServiceClient) GetOrgByID(arg0 context.Context, arg1 *grpc.OrgID, arg2 ...grpc0.CallOption) (*grpc.Org, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOrgByID", varargs...) + ret0, _ := ret[0].(*grpc.Org) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrgByID indicates an expected call of GetOrgByID +func (mr *MockManagementServiceClientMockRecorder) GetOrgByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgByID", reflect.TypeOf((*MockManagementServiceClient)(nil).GetOrgByID), varargs...) +} + +// GetOrgMemberRoles mocks base method +func (m *MockManagementServiceClient) GetOrgMemberRoles(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*grpc.OrgMemberRoles, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetOrgMemberRoles", varargs...) + ret0, _ := ret[0].(*grpc.OrgMemberRoles) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrgMemberRoles indicates an expected call of GetOrgMemberRoles +func (mr *MockManagementServiceClientMockRecorder) GetOrgMemberRoles(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrgMemberRoles", reflect.TypeOf((*MockManagementServiceClient)(nil).GetOrgMemberRoles), varargs...) +} + +// GetPasswordAgePolicy mocks base method +func (m *MockManagementServiceClient) GetPasswordAgePolicy(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*grpc.PasswordAgePolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPasswordAgePolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordAgePolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPasswordAgePolicy indicates an expected call of GetPasswordAgePolicy +func (mr *MockManagementServiceClientMockRecorder) GetPasswordAgePolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordAgePolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).GetPasswordAgePolicy), varargs...) +} + +// GetPasswordComplexityPolicy mocks base method +func (m *MockManagementServiceClient) GetPasswordComplexityPolicy(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*grpc.PasswordComplexityPolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPasswordComplexityPolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordComplexityPolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPasswordComplexityPolicy indicates an expected call of GetPasswordComplexityPolicy +func (mr *MockManagementServiceClientMockRecorder) GetPasswordComplexityPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordComplexityPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).GetPasswordComplexityPolicy), varargs...) +} + +// GetPasswordLockoutPolicy mocks base method +func (m *MockManagementServiceClient) GetPasswordLockoutPolicy(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*grpc.PasswordLockoutPolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPasswordLockoutPolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordLockoutPolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPasswordLockoutPolicy indicates an expected call of GetPasswordLockoutPolicy +func (mr *MockManagementServiceClientMockRecorder) GetPasswordLockoutPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordLockoutPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).GetPasswordLockoutPolicy), varargs...) +} + +// GetProjectGrantMemberRoles mocks base method +func (m *MockManagementServiceClient) GetProjectGrantMemberRoles(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantMemberRoles, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetProjectGrantMemberRoles", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrantMemberRoles) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectGrantMemberRoles indicates an expected call of GetProjectGrantMemberRoles +func (mr *MockManagementServiceClientMockRecorder) GetProjectGrantMemberRoles(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectGrantMemberRoles", reflect.TypeOf((*MockManagementServiceClient)(nil).GetProjectGrantMemberRoles), varargs...) +} + +// GetProjectMemberRoles mocks base method +func (m *MockManagementServiceClient) GetProjectMemberRoles(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*grpc.ProjectMemberRoles, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetProjectMemberRoles", varargs...) + ret0, _ := ret[0].(*grpc.ProjectMemberRoles) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetProjectMemberRoles indicates an expected call of GetProjectMemberRoles +func (mr *MockManagementServiceClientMockRecorder) GetProjectMemberRoles(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProjectMemberRoles", reflect.TypeOf((*MockManagementServiceClient)(nil).GetProjectMemberRoles), varargs...) +} + +// GetUserAddress mocks base method +func (m *MockManagementServiceClient) GetUserAddress(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserAddress, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserAddress", varargs...) + ret0, _ := ret[0].(*grpc.UserAddress) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserAddress indicates an expected call of GetUserAddress +func (mr *MockManagementServiceClientMockRecorder) GetUserAddress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAddress", reflect.TypeOf((*MockManagementServiceClient)(nil).GetUserAddress), varargs...) +} + +// GetUserByEmailGlobal mocks base method +func (m *MockManagementServiceClient) GetUserByEmailGlobal(arg0 context.Context, arg1 *grpc.UserEmailID, arg2 ...grpc0.CallOption) (*grpc.User, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserByEmailGlobal", varargs...) + ret0, _ := ret[0].(*grpc.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByEmailGlobal indicates an expected call of GetUserByEmailGlobal +func (mr *MockManagementServiceClientMockRecorder) GetUserByEmailGlobal(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByEmailGlobal", reflect.TypeOf((*MockManagementServiceClient)(nil).GetUserByEmailGlobal), varargs...) +} + +// GetUserByID mocks base method +func (m *MockManagementServiceClient) GetUserByID(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserByID", varargs...) + ret0, _ := ret[0].(*grpc.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserByID indicates an expected call of GetUserByID +func (mr *MockManagementServiceClientMockRecorder) GetUserByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserByID", reflect.TypeOf((*MockManagementServiceClient)(nil).GetUserByID), varargs...) +} + +// GetUserEmail mocks base method +func (m *MockManagementServiceClient) GetUserEmail(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserEmail, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserEmail", varargs...) + ret0, _ := ret[0].(*grpc.UserEmail) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserEmail indicates an expected call of GetUserEmail +func (mr *MockManagementServiceClientMockRecorder) GetUserEmail(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserEmail", reflect.TypeOf((*MockManagementServiceClient)(nil).GetUserEmail), varargs...) +} + +// GetUserMfas mocks base method +func (m *MockManagementServiceClient) GetUserMfas(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.MultiFactors, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserMfas", varargs...) + ret0, _ := ret[0].(*grpc.MultiFactors) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserMfas indicates an expected call of GetUserMfas +func (mr *MockManagementServiceClientMockRecorder) GetUserMfas(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserMfas", reflect.TypeOf((*MockManagementServiceClient)(nil).GetUserMfas), varargs...) +} + +// GetUserPhone mocks base method +func (m *MockManagementServiceClient) GetUserPhone(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserPhone, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserPhone", varargs...) + ret0, _ := ret[0].(*grpc.UserPhone) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserPhone indicates an expected call of GetUserPhone +func (mr *MockManagementServiceClientMockRecorder) GetUserPhone(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPhone", reflect.TypeOf((*MockManagementServiceClient)(nil).GetUserPhone), varargs...) +} + +// GetUserProfile mocks base method +func (m *MockManagementServiceClient) GetUserProfile(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.UserProfile, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetUserProfile", varargs...) + ret0, _ := ret[0].(*grpc.UserProfile) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetUserProfile indicates an expected call of GetUserProfile +func (mr *MockManagementServiceClientMockRecorder) GetUserProfile(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserProfile", reflect.TypeOf((*MockManagementServiceClient)(nil).GetUserProfile), varargs...) +} + +// Healthz mocks base method +func (m *MockManagementServiceClient) Healthz(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Healthz indicates an expected call of Healthz +func (mr *MockManagementServiceClientMockRecorder) Healthz(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Healthz", reflect.TypeOf((*MockManagementServiceClient)(nil).Healthz), varargs...) +} + +// IsUserUnique mocks base method +func (m *MockManagementServiceClient) IsUserUnique(arg0 context.Context, arg1 *grpc.UniqueUserRequest, arg2 ...grpc0.CallOption) (*grpc.UniqueUserResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "IsUserUnique", varargs...) + ret0, _ := ret[0].(*grpc.UniqueUserResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// IsUserUnique indicates an expected call of IsUserUnique +func (mr *MockManagementServiceClientMockRecorder) IsUserUnique(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsUserUnique", reflect.TypeOf((*MockManagementServiceClient)(nil).IsUserUnique), varargs...) +} + +// LockUser mocks base method +func (m *MockManagementServiceClient) LockUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LockUser", varargs...) + ret0, _ := ret[0].(*grpc.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// LockUser indicates an expected call of LockUser +func (mr *MockManagementServiceClientMockRecorder) LockUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockUser", reflect.TypeOf((*MockManagementServiceClient)(nil).LockUser), varargs...) +} + +// OrgChanges mocks base method +func (m *MockManagementServiceClient) OrgChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "OrgChanges", varargs...) + ret0, _ := ret[0].(*grpc.Changes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// OrgChanges indicates an expected call of OrgChanges +func (mr *MockManagementServiceClientMockRecorder) OrgChanges(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrgChanges", reflect.TypeOf((*MockManagementServiceClient)(nil).OrgChanges), varargs...) +} + +// ProjectByID mocks base method +func (m *MockManagementServiceClient) ProjectByID(arg0 context.Context, arg1 *grpc.ProjectID, arg2 ...grpc0.CallOption) (*grpc.Project, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ProjectByID", varargs...) + ret0, _ := ret[0].(*grpc.Project) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectByID indicates an expected call of ProjectByID +func (mr *MockManagementServiceClientMockRecorder) ProjectByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectByID", reflect.TypeOf((*MockManagementServiceClient)(nil).ProjectByID), varargs...) +} + +// ProjectChanges mocks base method +func (m *MockManagementServiceClient) ProjectChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ProjectChanges", varargs...) + ret0, _ := ret[0].(*grpc.Changes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectChanges indicates an expected call of ProjectChanges +func (mr *MockManagementServiceClientMockRecorder) ProjectChanges(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectChanges", reflect.TypeOf((*MockManagementServiceClient)(nil).ProjectChanges), varargs...) +} + +// ProjectGrantByID mocks base method +func (m *MockManagementServiceClient) ProjectGrantByID(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ProjectGrantByID", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectGrantByID indicates an expected call of ProjectGrantByID +func (mr *MockManagementServiceClientMockRecorder) ProjectGrantByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectGrantByID", reflect.TypeOf((*MockManagementServiceClient)(nil).ProjectGrantByID), varargs...) +} + +// ProjectGrantUserGrantByID mocks base method +func (m *MockManagementServiceClient) ProjectGrantUserGrantByID(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ProjectGrantUserGrantByID", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectGrantUserGrantByID indicates an expected call of ProjectGrantUserGrantByID +func (mr *MockManagementServiceClientMockRecorder) ProjectGrantUserGrantByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectGrantUserGrantByID", reflect.TypeOf((*MockManagementServiceClient)(nil).ProjectGrantUserGrantByID), varargs...) +} + +// ProjectUserGrantByID mocks base method +func (m *MockManagementServiceClient) ProjectUserGrantByID(arg0 context.Context, arg1 *grpc.ProjectUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ProjectUserGrantByID", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ProjectUserGrantByID indicates an expected call of ProjectUserGrantByID +func (mr *MockManagementServiceClientMockRecorder) ProjectUserGrantByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProjectUserGrantByID", reflect.TypeOf((*MockManagementServiceClient)(nil).ProjectUserGrantByID), varargs...) +} + +// ReactivateApplication mocks base method +func (m *MockManagementServiceClient) ReactivateApplication(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.Application, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateApplication", varargs...) + ret0, _ := ret[0].(*grpc.Application) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateApplication indicates an expected call of ReactivateApplication +func (mr *MockManagementServiceClientMockRecorder) ReactivateApplication(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateApplication", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateApplication), varargs...) +} + +// ReactivateOrg mocks base method +func (m *MockManagementServiceClient) ReactivateOrg(arg0 context.Context, arg1 *grpc.OrgID, arg2 ...grpc0.CallOption) (*grpc.Org, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateOrg", varargs...) + ret0, _ := ret[0].(*grpc.Org) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateOrg indicates an expected call of ReactivateOrg +func (mr *MockManagementServiceClientMockRecorder) ReactivateOrg(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateOrg", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateOrg), varargs...) +} + +// ReactivateProject mocks base method +func (m *MockManagementServiceClient) ReactivateProject(arg0 context.Context, arg1 *grpc.ProjectID, arg2 ...grpc0.CallOption) (*grpc.Project, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateProject", varargs...) + ret0, _ := ret[0].(*grpc.Project) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateProject indicates an expected call of ReactivateProject +func (mr *MockManagementServiceClientMockRecorder) ReactivateProject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateProject", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateProject), varargs...) +} + +// ReactivateProjectGrant mocks base method +func (m *MockManagementServiceClient) ReactivateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantID, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateProjectGrant", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateProjectGrant indicates an expected call of ReactivateProjectGrant +func (mr *MockManagementServiceClientMockRecorder) ReactivateProjectGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateProjectGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateProjectGrant), varargs...) +} + +// ReactivateProjectGrantUserGrant mocks base method +func (m *MockManagementServiceClient) ReactivateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateProjectGrantUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateProjectGrantUserGrant indicates an expected call of ReactivateProjectGrantUserGrant +func (mr *MockManagementServiceClientMockRecorder) ReactivateProjectGrantUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateProjectGrantUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateProjectGrantUserGrant), varargs...) +} + +// ReactivateProjectUserGrant mocks base method +func (m *MockManagementServiceClient) ReactivateProjectUserGrant(arg0 context.Context, arg1 *grpc.ProjectUserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateProjectUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateProjectUserGrant indicates an expected call of ReactivateProjectUserGrant +func (mr *MockManagementServiceClientMockRecorder) ReactivateProjectUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateProjectUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateProjectUserGrant), varargs...) +} + +// ReactivateUser mocks base method +func (m *MockManagementServiceClient) ReactivateUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateUser", varargs...) + ret0, _ := ret[0].(*grpc.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateUser indicates an expected call of ReactivateUser +func (mr *MockManagementServiceClientMockRecorder) ReactivateUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateUser", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateUser), varargs...) +} + +// ReactivateUserGrant mocks base method +func (m *MockManagementServiceClient) ReactivateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ReactivateUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReactivateUserGrant indicates an expected call of ReactivateUserGrant +func (mr *MockManagementServiceClientMockRecorder) ReactivateUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReactivateUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).ReactivateUserGrant), varargs...) +} + +// Ready mocks base method +func (m *MockManagementServiceClient) Ready(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Ready", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Ready indicates an expected call of Ready +func (mr *MockManagementServiceClientMockRecorder) Ready(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ready", reflect.TypeOf((*MockManagementServiceClient)(nil).Ready), varargs...) +} + +// RegenerateOIDCClientSecret mocks base method +func (m *MockManagementServiceClient) RegenerateOIDCClientSecret(arg0 context.Context, arg1 *grpc.ApplicationID, arg2 ...grpc0.CallOption) (*grpc.ClientSecret, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegenerateOIDCClientSecret", varargs...) + ret0, _ := ret[0].(*grpc.ClientSecret) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegenerateOIDCClientSecret indicates an expected call of RegenerateOIDCClientSecret +func (mr *MockManagementServiceClientMockRecorder) RegenerateOIDCClientSecret(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegenerateOIDCClientSecret", reflect.TypeOf((*MockManagementServiceClient)(nil).RegenerateOIDCClientSecret), varargs...) +} + +// RemoveOrgMember mocks base method +func (m *MockManagementServiceClient) RemoveOrgMember(arg0 context.Context, arg1 *grpc.RemoveOrgMemberRequest, arg2 ...grpc0.CallOption) (*empty.Empty, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RemoveOrgMember", varargs...) + ret0, _ := ret[0].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveOrgMember indicates an expected call of RemoveOrgMember +func (mr *MockManagementServiceClientMockRecorder) RemoveOrgMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveOrgMember", reflect.TypeOf((*MockManagementServiceClient)(nil).RemoveOrgMember), varargs...) +} + +// RemoveProjectGrantMember mocks base method +func (m *MockManagementServiceClient) RemoveProjectGrantMember(arg0 context.Context, arg1 *grpc.ProjectGrantMemberRemove, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveProjectGrantMember indicates an expected call of RemoveProjectGrantMember +func (mr *MockManagementServiceClientMockRecorder) RemoveProjectGrantMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProjectGrantMember", reflect.TypeOf((*MockManagementServiceClient)(nil).RemoveProjectGrantMember), varargs...) +} + +// RemoveProjectMember mocks base method +func (m *MockManagementServiceClient) RemoveProjectMember(arg0 context.Context, arg1 *grpc.ProjectMemberRemove, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RemoveProjectMember indicates an expected call of RemoveProjectMember +func (mr *MockManagementServiceClientMockRecorder) RemoveProjectMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveProjectMember", reflect.TypeOf((*MockManagementServiceClient)(nil).RemoveProjectMember), varargs...) +} + +// RemoveProjectRole mocks base method +func (m *MockManagementServiceClient) RemoveProjectRole(arg0 context.Context, arg1 *grpc.ProjectRoleRemove, arg2 ...grpc0.CallOption) (*empty.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].(*empty.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...) +} + +// ResendEmailVerificationMail mocks base method +func (m *MockManagementServiceClient) ResendEmailVerificationMail(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResendEmailVerificationMail indicates an expected call of ResendEmailVerificationMail +func (mr *MockManagementServiceClientMockRecorder) ResendEmailVerificationMail(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendEmailVerificationMail", reflect.TypeOf((*MockManagementServiceClient)(nil).ResendEmailVerificationMail), varargs...) +} + +// ResendPhoneVerificationCode mocks base method +func (m *MockManagementServiceClient) ResendPhoneVerificationCode(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResendPhoneVerificationCode indicates an expected call of ResendPhoneVerificationCode +func (mr *MockManagementServiceClientMockRecorder) ResendPhoneVerificationCode(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendPhoneVerificationCode", reflect.TypeOf((*MockManagementServiceClient)(nil).ResendPhoneVerificationCode), varargs...) +} + +// SearchApplications mocks base method +func (m *MockManagementServiceClient) SearchApplications(arg0 context.Context, arg1 *grpc.ApplicationSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ApplicationSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchApplications", varargs...) + ret0, _ := ret[0].(*grpc.ApplicationSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchApplications indicates an expected call of SearchApplications +func (mr *MockManagementServiceClientMockRecorder) SearchApplications(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchApplications", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchApplications), varargs...) +} + +// SearchAuthGrant mocks base method +func (m *MockManagementServiceClient) SearchAuthGrant(arg0 context.Context, arg1 *grpc.AuthGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.AuthGrantSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchAuthGrant", varargs...) + ret0, _ := ret[0].(*grpc.AuthGrantSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchAuthGrant indicates an expected call of SearchAuthGrant +func (mr *MockManagementServiceClientMockRecorder) SearchAuthGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchAuthGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchAuthGrant), varargs...) +} + +// SearchOrgMembers mocks base method +func (m *MockManagementServiceClient) SearchOrgMembers(arg0 context.Context, arg1 *grpc.OrgMemberSearchRequest, arg2 ...grpc0.CallOption) (*grpc.OrgMemberSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchOrgMembers", varargs...) + ret0, _ := ret[0].(*grpc.OrgMemberSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchOrgMembers indicates an expected call of SearchOrgMembers +func (mr *MockManagementServiceClientMockRecorder) SearchOrgMembers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchOrgMembers", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchOrgMembers), varargs...) +} + +// SearchProjectGrantMembers mocks base method +func (m *MockManagementServiceClient) SearchProjectGrantMembers(arg0 context.Context, arg1 *grpc.ProjectGrantMemberSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantMemberSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchProjectGrantMembers", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrantMemberSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchProjectGrantMembers indicates an expected call of SearchProjectGrantMembers +func (mr *MockManagementServiceClientMockRecorder) SearchProjectGrantMembers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProjectGrantMembers", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchProjectGrantMembers), varargs...) +} + +// SearchProjectGrantUserGrants mocks base method +func (m *MockManagementServiceClient) SearchProjectGrantUserGrants(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserGrantSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchProjectGrantUserGrants", varargs...) + ret0, _ := ret[0].(*grpc.UserGrantSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchProjectGrantUserGrants indicates an expected call of SearchProjectGrantUserGrants +func (mr *MockManagementServiceClientMockRecorder) SearchProjectGrantUserGrants(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProjectGrantUserGrants", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchProjectGrantUserGrants), varargs...) +} + +// SearchProjectGrants mocks base method +func (m *MockManagementServiceClient) SearchProjectGrants(arg0 context.Context, arg1 *grpc.ProjectGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectGrantSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchProjectGrants", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrantSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchProjectGrants indicates an expected call of SearchProjectGrants +func (mr *MockManagementServiceClientMockRecorder) SearchProjectGrants(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProjectGrants", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchProjectGrants), varargs...) +} + +// SearchProjectMembers mocks base method +func (m *MockManagementServiceClient) SearchProjectMembers(arg0 context.Context, arg1 *grpc.ProjectMemberSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectMemberSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchProjectMembers", varargs...) + ret0, _ := ret[0].(*grpc.ProjectMemberSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchProjectMembers indicates an expected call of SearchProjectMembers +func (mr *MockManagementServiceClientMockRecorder) SearchProjectMembers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProjectMembers", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchProjectMembers), varargs...) +} + +// SearchProjectRoles mocks base method +func (m *MockManagementServiceClient) SearchProjectRoles(arg0 context.Context, arg1 *grpc.ProjectRoleSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectRoleSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchProjectRoles", varargs...) + ret0, _ := ret[0].(*grpc.ProjectRoleSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchProjectRoles indicates an expected call of SearchProjectRoles +func (mr *MockManagementServiceClientMockRecorder) SearchProjectRoles(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProjectRoles", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchProjectRoles), varargs...) +} + +// SearchProjectUserGrants mocks base method +func (m *MockManagementServiceClient) SearchProjectUserGrants(arg0 context.Context, arg1 *grpc.ProjectUserGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserGrantSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchProjectUserGrants", varargs...) + ret0, _ := ret[0].(*grpc.UserGrantSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchProjectUserGrants indicates an expected call of SearchProjectUserGrants +func (mr *MockManagementServiceClientMockRecorder) SearchProjectUserGrants(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProjectUserGrants", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchProjectUserGrants), varargs...) +} + +// SearchProjects mocks base method +func (m *MockManagementServiceClient) SearchProjects(arg0 context.Context, arg1 *grpc.ProjectSearchRequest, arg2 ...grpc0.CallOption) (*grpc.ProjectSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchProjects", varargs...) + ret0, _ := ret[0].(*grpc.ProjectSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchProjects indicates an expected call of SearchProjects +func (mr *MockManagementServiceClientMockRecorder) SearchProjects(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchProjects", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchProjects), varargs...) +} + +// SearchUserGrants mocks base method +func (m *MockManagementServiceClient) SearchUserGrants(arg0 context.Context, arg1 *grpc.UserGrantSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserGrantSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchUserGrants", varargs...) + ret0, _ := ret[0].(*grpc.UserGrantSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchUserGrants indicates an expected call of SearchUserGrants +func (mr *MockManagementServiceClientMockRecorder) SearchUserGrants(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchUserGrants", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchUserGrants), varargs...) +} + +// SearchUsers mocks base method +func (m *MockManagementServiceClient) SearchUsers(arg0 context.Context, arg1 *grpc.UserSearchRequest, arg2 ...grpc0.CallOption) (*grpc.UserSearchResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SearchUsers", varargs...) + ret0, _ := ret[0].(*grpc.UserSearchResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SearchUsers indicates an expected call of SearchUsers +func (mr *MockManagementServiceClientMockRecorder) SearchUsers(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchUsers", reflect.TypeOf((*MockManagementServiceClient)(nil).SearchUsers), varargs...) +} + +// SendSetPasswordNotification mocks base method +func (m *MockManagementServiceClient) SendSetPasswordNotification(arg0 context.Context, arg1 *grpc.SetPasswordNotificationRequest, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SendSetPasswordNotification indicates an expected call of SendSetPasswordNotification +func (mr *MockManagementServiceClientMockRecorder) SendSetPasswordNotification(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendSetPasswordNotification", reflect.TypeOf((*MockManagementServiceClient)(nil).SendSetPasswordNotification), varargs...) +} + +// SetInitialPassword mocks base method +func (m *MockManagementServiceClient) SetInitialPassword(arg0 context.Context, arg1 *grpc.PasswordRequest, arg2 ...grpc0.CallOption) (*empty.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].(*empty.Empty) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetInitialPassword indicates an expected call of SetInitialPassword +func (mr *MockManagementServiceClientMockRecorder) SetInitialPassword(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInitialPassword", reflect.TypeOf((*MockManagementServiceClient)(nil).SetInitialPassword), varargs...) +} + +// UnlockUser mocks base method +func (m *MockManagementServiceClient) UnlockUser(arg0 context.Context, arg1 *grpc.UserID, arg2 ...grpc0.CallOption) (*grpc.User, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnlockUser", varargs...) + ret0, _ := ret[0].(*grpc.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UnlockUser indicates an expected call of UnlockUser +func (mr *MockManagementServiceClientMockRecorder) UnlockUser(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockUser", reflect.TypeOf((*MockManagementServiceClient)(nil).UnlockUser), varargs...) +} + +// UpdateApplication mocks base method +func (m *MockManagementServiceClient) UpdateApplication(arg0 context.Context, arg1 *grpc.ApplicationUpdate, arg2 ...grpc0.CallOption) (*grpc.Application, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateApplication", varargs...) + ret0, _ := ret[0].(*grpc.Application) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateApplication indicates an expected call of UpdateApplication +func (mr *MockManagementServiceClientMockRecorder) UpdateApplication(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApplication", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateApplication), varargs...) +} + +// UpdateApplicationOIDCConfig mocks base method +func (m *MockManagementServiceClient) UpdateApplicationOIDCConfig(arg0 context.Context, arg1 *grpc.OIDCConfigUpdate, arg2 ...grpc0.CallOption) (*grpc.OIDCConfig, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateApplicationOIDCConfig", varargs...) + ret0, _ := ret[0].(*grpc.OIDCConfig) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateApplicationOIDCConfig indicates an expected call of UpdateApplicationOIDCConfig +func (mr *MockManagementServiceClientMockRecorder) UpdateApplicationOIDCConfig(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApplicationOIDCConfig", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateApplicationOIDCConfig), varargs...) +} + +// UpdatePasswordAgePolicy mocks base method +func (m *MockManagementServiceClient) UpdatePasswordAgePolicy(arg0 context.Context, arg1 *grpc.PasswordAgePolicyUpdate, arg2 ...grpc0.CallOption) (*grpc.PasswordAgePolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePasswordAgePolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordAgePolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePasswordAgePolicy indicates an expected call of UpdatePasswordAgePolicy +func (mr *MockManagementServiceClientMockRecorder) UpdatePasswordAgePolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePasswordAgePolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdatePasswordAgePolicy), varargs...) +} + +// UpdatePasswordComplexityPolicy mocks base method +func (m *MockManagementServiceClient) UpdatePasswordComplexityPolicy(arg0 context.Context, arg1 *grpc.PasswordComplexityPolicyUpdate, arg2 ...grpc0.CallOption) (*grpc.PasswordComplexityPolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePasswordComplexityPolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordComplexityPolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePasswordComplexityPolicy indicates an expected call of UpdatePasswordComplexityPolicy +func (mr *MockManagementServiceClientMockRecorder) UpdatePasswordComplexityPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePasswordComplexityPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdatePasswordComplexityPolicy), varargs...) +} + +// UpdatePasswordLockoutPolicy mocks base method +func (m *MockManagementServiceClient) UpdatePasswordLockoutPolicy(arg0 context.Context, arg1 *grpc.PasswordLockoutPolicyUpdate, arg2 ...grpc0.CallOption) (*grpc.PasswordLockoutPolicy, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePasswordLockoutPolicy", varargs...) + ret0, _ := ret[0].(*grpc.PasswordLockoutPolicy) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePasswordLockoutPolicy indicates an expected call of UpdatePasswordLockoutPolicy +func (mr *MockManagementServiceClientMockRecorder) UpdatePasswordLockoutPolicy(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePasswordLockoutPolicy", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdatePasswordLockoutPolicy), varargs...) +} + +// UpdateProject mocks base method +func (m *MockManagementServiceClient) UpdateProject(arg0 context.Context, arg1 *grpc.ProjectUpdateRequest, arg2 ...grpc0.CallOption) (*grpc.Project, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateProject", varargs...) + ret0, _ := ret[0].(*grpc.Project) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProject indicates an expected call of UpdateProject +func (mr *MockManagementServiceClientMockRecorder) UpdateProject(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProject", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateProject), varargs...) +} + +// UpdateProjectGrant mocks base method +func (m *MockManagementServiceClient) UpdateProjectGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.ProjectGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateProjectGrant", varargs...) + ret0, _ := ret[0].(*grpc.ProjectGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProjectGrant indicates an expected call of UpdateProjectGrant +func (mr *MockManagementServiceClientMockRecorder) UpdateProjectGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProjectGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateProjectGrant), varargs...) +} + +// UpdateProjectGrantUserGrant mocks base method +func (m *MockManagementServiceClient) UpdateProjectGrantUserGrant(arg0 context.Context, arg1 *grpc.ProjectGrantUserGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateProjectGrantUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProjectGrantUserGrant indicates an expected call of UpdateProjectGrantUserGrant +func (mr *MockManagementServiceClientMockRecorder) UpdateProjectGrantUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProjectGrantUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateProjectGrantUserGrant), varargs...) +} + +// UpdateProjectUserGrant mocks base method +func (m *MockManagementServiceClient) UpdateProjectUserGrant(arg0 context.Context, arg1 *grpc.ProjectUserGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateProjectUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateProjectUserGrant indicates an expected call of UpdateProjectUserGrant +func (mr *MockManagementServiceClientMockRecorder) UpdateProjectUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProjectUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateProjectUserGrant), varargs...) +} + +// UpdateUserAddress mocks base method +func (m *MockManagementServiceClient) UpdateUserAddress(arg0 context.Context, arg1 *grpc.UpdateUserAddressRequest, arg2 ...grpc0.CallOption) (*grpc.UserAddress, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateUserAddress", varargs...) + ret0, _ := ret[0].(*grpc.UserAddress) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateUserAddress indicates an expected call of UpdateUserAddress +func (mr *MockManagementServiceClientMockRecorder) UpdateUserAddress(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserAddress", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateUserAddress), varargs...) +} + +// UpdateUserGrant mocks base method +func (m *MockManagementServiceClient) UpdateUserGrant(arg0 context.Context, arg1 *grpc.UserGrantUpdate, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateUserGrant", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateUserGrant indicates an expected call of UpdateUserGrant +func (mr *MockManagementServiceClientMockRecorder) UpdateUserGrant(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserGrant", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateUserGrant), varargs...) +} + +// UpdateUserProfile mocks base method +func (m *MockManagementServiceClient) UpdateUserProfile(arg0 context.Context, arg1 *grpc.UpdateUserProfileRequest, arg2 ...grpc0.CallOption) (*grpc.UserProfile, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateUserProfile", varargs...) + ret0, _ := ret[0].(*grpc.UserProfile) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateUserProfile indicates an expected call of UpdateUserProfile +func (mr *MockManagementServiceClientMockRecorder) UpdateUserProfile(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserProfile", reflect.TypeOf((*MockManagementServiceClient)(nil).UpdateUserProfile), varargs...) +} + +// UserChanges mocks base method +func (m *MockManagementServiceClient) UserChanges(arg0 context.Context, arg1 *grpc.ChangeRequest, arg2 ...grpc0.CallOption) (*grpc.Changes, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UserChanges", varargs...) + ret0, _ := ret[0].(*grpc.Changes) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UserChanges indicates an expected call of UserChanges +func (mr *MockManagementServiceClientMockRecorder) UserChanges(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserChanges", reflect.TypeOf((*MockManagementServiceClient)(nil).UserChanges), varargs...) +} + +// UserGrantByID mocks base method +func (m *MockManagementServiceClient) UserGrantByID(arg0 context.Context, arg1 *grpc.UserGrantID, arg2 ...grpc0.CallOption) (*grpc.UserGrant, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UserGrantByID", varargs...) + ret0, _ := ret[0].(*grpc.UserGrant) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UserGrantByID indicates an expected call of UserGrantByID +func (mr *MockManagementServiceClientMockRecorder) UserGrantByID(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserGrantByID", reflect.TypeOf((*MockManagementServiceClient)(nil).UserGrantByID), varargs...) +} + +// Validate mocks base method +func (m *MockManagementServiceClient) Validate(arg0 context.Context, arg1 *empty.Empty, arg2 ...grpc0.CallOption) (*struct0.Struct, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Validate", varargs...) + ret0, _ := ret[0].(*struct0.Struct) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Validate indicates an expected call of Validate +func (mr *MockManagementServiceClientMockRecorder) Validate(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validate", reflect.TypeOf((*MockManagementServiceClient)(nil).Validate), varargs...) +}