From 8a8b32893dbf613f56f5953cde570632e8878756 Mon Sep 17 00:00:00 2001 From: hanny21 Date: Mon, 9 Jan 2023 10:03:26 +0100 Subject: [PATCH] feat: upgrade identity api to v1beta2 --- authorization/is_authorized.go | 54 +- examples/identity/cmd/change_password.go | 16 +- examples/identity/cmd/consent.go | 10 +- examples/identity/cmd/delete_digital_twin.go | 14 +- examples/identity/cmd/enrich_token.go | 2 +- examples/identity/cmd/get_digital_twin.go | 14 +- examples/identity/cmd/is_authorized.go | 15 +- examples/identity/cmd/patch_properties.go | 14 +- examples/identity/cmd/verify_email.go | 18 +- .../v1beta1/authorization_service.pb.go | 59 +- .../authorization_service.pb.validate.go | 96 +- .../v1beta1/authorization_service_grpc.pb.go | 1 + .../v1beta1/config_management_api.pb.go | 8 +- .../v1beta1/config_management_api_grpc.pb.go | 1 + gen/indykite/config/v1beta1/model.pb.go | 13 +- gen/indykite/events/v1beta1/events.pb.go | 8 +- .../identity/v1beta1/attributes.pb.go | 48 +- gen/indykite/identity/v1beta1/authenteq.pb.go | 5 +- gen/indykite/identity/v1beta1/document.pb.go | 8 +- .../v1beta1/identity_management_api.pb.go | 13 +- .../identity_management_api_grpc.pb.go | 1 + gen/indykite/identity/v1beta1/import.pb.go | 8 +- gen/indykite/identity/v1beta1/model.pb.go | 11 +- .../identity/v1beta2/attributes.ext.go | 207 ++ .../identity/v1beta2/attributes.pb.go | 48 +- gen/indykite/identity/v1beta2/authenteq.pb.go | 5 +- gen/indykite/identity/v1beta2/consent.pb.go | 5 +- gen/indykite/identity/v1beta2/doc.go | 16 + gen/indykite/identity/v1beta2/document.pb.go | 8 +- .../v1beta2/identity_management_api.pb.go | 13 +- .../identity_management_api_grpc.pb.go | 1 + gen/indykite/identity/v1beta2/import.pb.go | 8 +- gen/indykite/identity/v1beta2/model.pb.go | 11 +- gen/indykite/identity/v1beta2/readid.pb.go | 5 +- gen/indykite/ingest/v1beta1/ingest_api.pb.go | 8 +- .../ingest/v1beta1/ingest_api_grpc.pb.go | 1 + gen/indykite/ingest/v1beta1/model.pb.go | 11 +- .../knowledge_graph/v1beta1/policy.pb.go | 11 +- gen/indykite/objects/v1beta1/struct.pb.go | 5 +- .../objects/v1beta1/struct.pb.validate.go | 1 - identity/authorization.go | 21 +- identity/consent.go | 14 +- identity/digital_twin.go | 22 +- identity/enrich_token.go | 2 +- identity/identity_client.go | 2 +- identity/invitation.go | 23 +- identity/invitation_test.go | 8 +- oauth2/token.go | 2 +- .../v1beta1/identity_management_api_mock.go | 3 +- .../v1beta2/identity_management_api_mock.go | 1669 +++++++++++++++++ 50 files changed, 2236 insertions(+), 331 deletions(-) create mode 100644 gen/indykite/identity/v1beta2/attributes.ext.go create mode 100644 gen/indykite/identity/v1beta2/doc.go create mode 100644 test/identity/v1beta2/identity_management_api_mock.go diff --git a/authorization/is_authorized.go b/authorization/is_authorized.go index 30565b7..d386613 100644 --- a/authorization/is_authorized.go +++ b/authorization/is_authorized.go @@ -41,9 +41,11 @@ func (c *Client) IsAuthorized( opts ...grpc.CallOption, ) (*authorizationpb.IsAuthorizedResponse, error) { return c.IsAuthorizedWithRawRequest(ctx, &authorizationpb.IsAuthorizedRequest{ - Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_DigitalTwin{ - DigitalTwin: digitalTwin, - }}, + Subject: &authorizationpb.IsAuthorizedRequest_DigitalTwinIdentifier{ + DigitalTwinIdentifier: &identitypb.DigitalTwinIdentifier{ + Filter: &identitypb.DigitalTwinIdentifier_DigitalTwin{DigitalTwin: digitalTwin}, + }, + }, Actions: actions, Resources: resources, }, opts...) @@ -59,9 +61,10 @@ func (c *Client) IsAuthorizedByToken( opts ...grpc.CallOption, ) (*authorizationpb.IsAuthorizedResponse, error) { return c.IsAuthorizedWithRawRequest(ctx, &authorizationpb.IsAuthorizedRequest{ - Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_AccessToken{ - AccessToken: token, - }}, + Subject: &authorizationpb.IsAuthorizedRequest_DigitalTwinIdentifier{ + DigitalTwinIdentifier: &identitypb.DigitalTwinIdentifier{ + Filter: &identitypb.DigitalTwinIdentifier_AccessToken{AccessToken: token}, + }}, Actions: actions, Resources: resources, }, opts...) @@ -77,12 +80,15 @@ func (c *Client) IsAuthorizedByStringExternalID( opts ...grpc.CallOption, ) (*authorizationpb.IsAuthorizedResponse, error) { return c.IsAuthorizedWithRawRequest(ctx, &authorizationpb.IsAuthorizedRequest{ - Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_PropertyFilter{ - PropertyFilter: &identitypb.PropertyFilter{ - Type: externalIDProperty, - Value: objects.String(externalID), - }, - }}, + Subject: &authorizationpb.IsAuthorizedRequest_DigitalTwinIdentifier{ + DigitalTwinIdentifier: &identitypb.DigitalTwinIdentifier{ + Filter: &identitypb.DigitalTwinIdentifier_PropertyFilter{ + PropertyFilter: &identitypb.PropertyFilter{ + Type: externalIDProperty, + Value: objects.String(externalID), + }, + }, + }}, Actions: actions, Resources: resources, }, opts...) @@ -98,12 +104,15 @@ func (c *Client) IsAuthorizedByNumericExternalID( opts ...grpc.CallOption, ) (*authorizationpb.IsAuthorizedResponse, error) { return c.IsAuthorizedWithRawRequest(ctx, &authorizationpb.IsAuthorizedRequest{ - Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_PropertyFilter{ - PropertyFilter: &identitypb.PropertyFilter{ - Type: externalIDProperty, - Value: objects.Int64(externalID), - }, - }}, + Subject: &authorizationpb.IsAuthorizedRequest_DigitalTwinIdentifier{ + DigitalTwinIdentifier: &identitypb.DigitalTwinIdentifier{ + Filter: &identitypb.DigitalTwinIdentifier_PropertyFilter{ + PropertyFilter: &identitypb.PropertyFilter{ + Type: externalIDProperty, + Value: objects.Int64(externalID), + }, + }, + }}, Actions: actions, Resources: resources, }, opts...) @@ -118,10 +127,11 @@ func (c *Client) IsAuthorizedWithRawRequest( return nil, errors.NewInvalidArgumentErrorWithCause(err, "unable to call IsAuthorized client endpoint") } - switch sub := req.Subject.Filter.(type) { - case *identitypb.DigitalTwinIdentifier_AccessToken: - if err := verifyTokenFormat(sub.AccessToken); err != nil { - return nil, err + if sub, ok := req.Subject.(*authorizationpb.IsAuthorizedRequest_DigitalTwinIdentifier); ok { + if filter, ok := sub.DigitalTwinIdentifier.Filter.(*identitypb.DigitalTwinIdentifier_AccessToken); ok { + if err := verifyTokenFormat(filter.AccessToken); err != nil { + return nil, err + } } } diff --git a/examples/identity/cmd/change_password.go b/examples/identity/cmd/change_password.go index 16b9f23..6d1e842 100644 --- a/examples/identity/cmd/change_password.go +++ b/examples/identity/cmd/change_password.go @@ -22,8 +22,7 @@ import ( "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry" "github.com/spf13/cobra" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" - "github.com/indykite/jarvis-sdk-go/identity" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) // changePwdCmd represents the plan command @@ -61,20 +60,11 @@ var changeDtPwdCmd = &cobra.Command{ fmt.Print("Enter new password: ") fmt.Scanln(&newPassword) - digitalTwinUUID, err := identity.ParseUUID(digitalTwinID) - if err != nil { - log.Fatalf("failed to parse digitalTwinID: %v", err) - } - tenantUUID, err := identity.ParseUUID(tenantID) - if err != nil { - log.Fatalf("failed to parse tenantID: %v", err) - } - resp, err := client.ChangePasswordOfDigitalTwin( context.Background(), &identitypb.DigitalTwin{ - Id: digitalTwinUUID, - TenantId: tenantUUID, + Id: digitalTwinID, + TenantId: tenantID, }, newPassword, retry.WithMax(2), diff --git a/examples/identity/cmd/consent.go b/examples/identity/cmd/consent.go index 19e5e0a..f26de1e 100644 --- a/examples/identity/cmd/consent.go +++ b/examples/identity/cmd/consent.go @@ -23,7 +23,7 @@ import ( "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry" "github.com/spf13/cobra" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) // planCmd represents the plan command @@ -47,7 +47,7 @@ var checkConsentChallengeCmd = &cobra.Command{ resp, err := client.CheckConsentChallenge( context.Background(), - &identitypb.CheckConsentChallengeRequest{Challenge: consentChallenge}, + &identitypb.CheckOAuth2ConsentChallengeRequest{Challenge: consentChallenge}, retry.WithMax(2), ) if err != nil { @@ -67,7 +67,7 @@ var createConsentVerifier = &cobra.Command{ var consentChallenge string fmt.Scanln(&consentChallenge) - req := &identitypb.CreateConsentVerifierRequest{Challenge: consentChallenge} + req := &identitypb.CreateOAuth2ConsentVerifierRequest{ConsentChallenge: consentChallenge} fmt.Print("Enter 1 for Approval or 2 for Denial: ") var result string fmt.Scanln(&result) @@ -85,7 +85,7 @@ var createConsentVerifier = &cobra.Command{ fmt.Println(jsonp.Format(denial)) - req.Result = &identitypb.CreateConsentVerifierRequest_Denial{Denial: denial} + req.Result = &identitypb.CreateOAuth2ConsentVerifierRequest_Denial{Denial: denial} default: approval := &identitypb.ConsentApproval{} for { @@ -97,7 +97,7 @@ var createConsentVerifier = &cobra.Command{ } approval.GrantScopes = append(approval.GrantScopes, scope) } - req.Result = &identitypb.CreateConsentVerifierRequest_Approval{Approval: approval} + req.Result = &identitypb.CreateOAuth2ConsentVerifierRequest_Approval{Approval: approval} } resp, err := client.CreateConsentVerifier(context.Background(), req, retry.WithMax(2)) diff --git a/examples/identity/cmd/delete_digital_twin.go b/examples/identity/cmd/delete_digital_twin.go index f040e86..ae83f17 100644 --- a/examples/identity/cmd/delete_digital_twin.go +++ b/examples/identity/cmd/delete_digital_twin.go @@ -22,8 +22,7 @@ import ( "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry" "github.com/spf13/cobra" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" - "github.com/indykite/jarvis-sdk-go/identity" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) // deleteDtTokenCmd represents the delte DigitalTwin command. @@ -66,18 +65,9 @@ var deleteDtCmd = &cobra.Command{ fmt.Print("Enter tenant_id: ") fmt.Scanln(&tenantID) - digitalTwinUUID, err := identity.ParseUUID(digitalTwinID) - if err != nil { - log.Fatalf("failed to parse digitalTwinID: %v", err) - } - tenantUUID, err := identity.ParseUUID(tenantID) - if err != nil { - log.Fatalf("failed to parse tenantID: %v", err) - } - resp, err := client.DeleteDigitalTwin( context.Background(), - &identitypb.DigitalTwin{Id: digitalTwinUUID, TenantId: tenantUUID}, + &identitypb.DigitalTwin{Id: digitalTwinID, TenantId: tenantID}, retry.WithMax(2), ) if err != nil { diff --git a/examples/identity/cmd/enrich_token.go b/examples/identity/cmd/enrich_token.go index aabfabc..909b0c0 100644 --- a/examples/identity/cmd/enrich_token.go +++ b/examples/identity/cmd/enrich_token.go @@ -23,7 +23,7 @@ import ( "github.com/spf13/cobra" "google.golang.org/protobuf/types/known/structpb" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) // enrichTokenCmd represents the enrichToken command diff --git a/examples/identity/cmd/get_digital_twin.go b/examples/identity/cmd/get_digital_twin.go index 1c9de58..cc77643 100644 --- a/examples/identity/cmd/get_digital_twin.go +++ b/examples/identity/cmd/get_digital_twin.go @@ -22,8 +22,7 @@ import ( "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry" "github.com/spf13/cobra" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" - "github.com/indykite/jarvis-sdk-go/identity" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) // planCmd represents the plan command @@ -68,18 +67,9 @@ var getDtCmd = &cobra.Command{ fmt.Print("Enter tenant_id: ") fmt.Scanln(&tenantID) - digitalTwinUUID, err := identity.ParseUUID(digitalTwinID) - if err != nil { - log.Fatalf("failed to parse digitalTwinID: %v", err) - } - tenantUUID, err := identity.ParseUUID(tenantID) - if err != nil { - log.Fatalf("failed to parse tenantID: %v", err) - } - resp, err := client.GetDigitalTwin( context.Background(), - &identitypb.DigitalTwin{Id: digitalTwinUUID, TenantId: tenantUUID}, + &identitypb.DigitalTwin{Id: digitalTwinID, TenantId: tenantID}, []*identitypb.PropertyMask{ {Definition: &identitypb.PropertyDefinition{Property: "email"}}, {Definition: &identitypb.PropertyDefinition{Property: "mobile"}}, diff --git a/examples/identity/cmd/is_authorized.go b/examples/identity/cmd/is_authorized.go index 2bd6014..60a2cfb 100644 --- a/examples/identity/cmd/is_authorized.go +++ b/examples/identity/cmd/is_authorized.go @@ -22,8 +22,7 @@ import ( "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry" "github.com/spf13/cobra" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" - "github.com/indykite/jarvis-sdk-go/identity" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) var isAuthorizedCmd = &cobra.Command{ @@ -75,17 +74,9 @@ var withDigitalTwinCmd = &cobra.Command{ fmt.Print("Enter tenant_id: ") fmt.Scanln(&tenantID) - digitalTwinUUID, err := identity.ParseUUID(digitalTwinID) - if err != nil { - log.Fatalf("failed to parse digitalTwinID: %v", err) - } - tenantUUID, err := identity.ParseUUID(tenantID) - if err != nil { - log.Fatalf("failed to parse tenantID: %v", err) - } digitalTwin := &identitypb.DigitalTwin{ - Id: digitalTwinUUID, - TenantId: tenantUUID, + Id: digitalTwinID, + TenantId: tenantID, } actions := []string{"ACTION"} diff --git a/examples/identity/cmd/patch_properties.go b/examples/identity/cmd/patch_properties.go index b0da85e..2d5939b 100644 --- a/examples/identity/cmd/patch_properties.go +++ b/examples/identity/cmd/patch_properties.go @@ -22,9 +22,8 @@ import ( "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry" "github.com/spf13/cobra" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" objects "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" - "github.com/indykite/jarvis-sdk-go/identity" ) // patchPropDtTokenCmd represents the patch command @@ -78,18 +77,9 @@ var patchPropDtCmd = &cobra.Command{ fmt.Print("Enter tenant_id: ") fmt.Scanln(&tenantID) - digitalTwinUUID, err := identity.ParseUUID(digitalTwinID) - if err != nil { - log.Fatalf("failed to parse digitalTwinID: %v", err) - } - tenantUUID, err := identity.ParseUUID(tenantID) - if err != nil { - log.Fatalf("failed to parse tenantID: %v", err) - } - resp, err := client.PatchDigitalTwin( context.Background(), - &identitypb.DigitalTwin{Id: digitalTwinUUID, TenantId: tenantUUID}, + &identitypb.DigitalTwin{Id: digitalTwinID, TenantId: tenantID}, []*identitypb.PropertyBatchOperation{ // {Operation: &identitypb.PropertyBatchOperation_Add{Add: &identitypb.Property{ // Definition: &identitypb.PropertyDefinition{Property: "email"}, diff --git a/examples/identity/cmd/verify_email.go b/examples/identity/cmd/verify_email.go index a3aab66..de2319a 100644 --- a/examples/identity/cmd/verify_email.go +++ b/examples/identity/cmd/verify_email.go @@ -22,9 +22,8 @@ import ( "github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/retry" "github.com/spf13/cobra" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" objects "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" - "github.com/indykite/jarvis-sdk-go/identity" ) // emailVerCmd represents the plan command @@ -43,22 +42,13 @@ var emailVerCmd = &cobra.Command{ fmt.Print("Enter email address: ") fmt.Scanln(&email) - digitalTwinUUID, err := identity.ParseUUID(digitalTwinID) - if err != nil { - log.Fatalf("failed to parse digitalTwinID: %v", err) - } - tenantUUID, err := identity.ParseUUID(tenantID) - if err != nil { - log.Fatalf("failed to parse tenantID: %v", err) - } - // anyPb, _ := anypb.New(wrapperspb.String("test")) // anyObject, _ := objects.Any(anyPb) - err = client.StartEmailVerification(context.Background(), + err := client.StartEmailVerification(context.Background(), &identitypb.DigitalTwin{ - TenantId: tenantUUID, - Id: digitalTwinUUID, + TenantId: tenantID, + Id: digitalTwinID, }, email, &objects.MapValue{ Fields: map[string]*objects.Value{ diff --git a/gen/indykite/authorization/v1beta1/authorization_service.pb.go b/gen/indykite/authorization/v1beta1/authorization_service.pb.go index 656166f..e7c08c1 100644 --- a/gen/indykite/authorization/v1beta1/authorization_service.pb.go +++ b/gen/indykite/authorization/v1beta1/authorization_service.pb.go @@ -23,13 +23,16 @@ package authorizationv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta2 "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta2 "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( @@ -44,8 +47,11 @@ type IsAuthorizedRequest struct { sizeCache protoimpl.SizeCache unknownFields protoimpl.UnknownFields - // Subject is DigitalTwin identifier to check if is authorized to perform given actions. - Subject *v1beta2.DigitalTwinIdentifier `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"` + // Subject to check if is authorized to perform given actions. + // + // Types that are assignable to Subject: + // *IsAuthorizedRequest_DigitalTwinIdentifier + Subject isIsAuthorizedRequest_Subject `protobuf_oneof:"subject"` // A list of resources to authorize against. Resources []*IsAuthorizedRequest_Resource `protobuf:"bytes,2,rep,name=resources,proto3" json:"resources,omitempty"` // A list of actions the subject want to perform. @@ -85,9 +91,16 @@ func (*IsAuthorizedRequest) Descriptor() ([]byte, []int) { return file_indykite_authorization_v1beta1_authorization_service_proto_rawDescGZIP(), []int{0} } -func (x *IsAuthorizedRequest) GetSubject() *v1beta2.DigitalTwinIdentifier { - if x != nil { - return x.Subject +func (m *IsAuthorizedRequest) GetSubject() isIsAuthorizedRequest_Subject { + if m != nil { + return m.Subject + } + return nil +} + +func (x *IsAuthorizedRequest) GetDigitalTwinIdentifier() *v1beta2.DigitalTwinIdentifier { + if x, ok := x.GetSubject().(*IsAuthorizedRequest_DigitalTwinIdentifier); ok { + return x.DigitalTwinIdentifier } return nil } @@ -106,6 +119,16 @@ func (x *IsAuthorizedRequest) GetActions() []string { return nil } +type isIsAuthorizedRequest_Subject interface { + isIsAuthorizedRequest_Subject() +} + +type IsAuthorizedRequest_DigitalTwinIdentifier struct { + DigitalTwinIdentifier *v1beta2.DigitalTwinIdentifier `protobuf:"bytes,1,opt,name=digital_twin_identifier,json=digitalTwinIdentifier,proto3,oneof"` +} + +func (*IsAuthorizedRequest_DigitalTwinIdentifier) isIsAuthorizedRequest_Subject() {} + type IsAuthorizedResponse struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -284,13 +307,15 @@ var file_indykite_authorization_v1beta1_authorization_service_proto_rawDesc = [] 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2f, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x32, 0x2f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x5f, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x61, 0x70, 0x69, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, - 0xf7, 0x02, 0x0a, 0x13, 0x49, 0x73, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x54, 0x0a, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, - 0x63, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x69, 0x6e, 0x64, 0x79, 0x6b, + 0xa7, 0x03, 0x0a, 0x13, 0x49, 0x73, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x74, 0x0a, 0x17, 0x64, 0x69, 0x67, 0x69, 0x74, + 0x61, 0x6c, 0x5f, 0x74, 0x77, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x69, 0x6e, 0x64, 0x79, 0x6b, 0x69, 0x74, 0x65, 0x2e, 0x69, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, 0x32, 0x2e, 0x44, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, 0x54, 0x77, 0x69, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x42, 0x08, 0xfa, 0x42, 0x05, 0x8a, - 0x01, 0x02, 0x10, 0x01, 0x52, 0x07, 0x73, 0x75, 0x62, 0x6a, 0x65, 0x63, 0x74, 0x12, 0x66, 0x0a, + 0x01, 0x02, 0x10, 0x01, 0x48, 0x00, 0x52, 0x15, 0x64, 0x69, 0x67, 0x69, 0x74, 0x61, 0x6c, 0x54, + 0x77, 0x69, 0x6e, 0x49, 0x64, 0x65, 0x6e, 0x74, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x66, 0x0a, 0x09, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x69, 0x6e, 0x64, 0x79, 0x6b, 0x69, 0x74, 0x65, 0x2e, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x76, 0x31, 0x62, 0x65, 0x74, 0x61, @@ -307,7 +332,8 @@ var file_indykite_authorization_v1beta1_authorization_service_proto_rawDesc = [] 0x52, 0x02, 0x69, 0x64, 0x12, 0x33, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x42, 0x1d, 0xfa, 0x42, 0x1a, 0x72, 0x18, 0x10, 0x02, 0x18, 0x32, 0x32, 0x12, 0x5e, 0x28, 0x3f, 0x3a, 0x5b, 0x41, 0x2d, 0x5a, 0x5d, 0x5b, 0x61, 0x2d, 0x7a, 0x5d, 0x2b, 0x29, - 0x2b, 0x24, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x22, 0xaf, 0x02, 0x0a, 0x14, 0x49, 0x73, + 0x2b, 0x24, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x42, 0x0e, 0x0a, 0x07, 0x73, 0x75, 0x62, + 0x6a, 0x65, 0x63, 0x74, 0x12, 0x03, 0xf8, 0x42, 0x01, 0x22, 0xaf, 0x02, 0x0a, 0x14, 0x49, 0x73, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x3f, 0x0a, 0x0d, 0x64, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, @@ -394,7 +420,7 @@ var file_indykite_authorization_v1beta1_authorization_service_proto_goTypes = [] (*timestamppb.Timestamp)(nil), // 7: google.protobuf.Timestamp } var file_indykite_authorization_v1beta1_authorization_service_proto_depIdxs = []int32{ - 6, // 0: indykite.authorization.v1beta1.IsAuthorizedRequest.subject:type_name -> indykite.identity.v1beta2.DigitalTwinIdentifier + 6, // 0: indykite.authorization.v1beta1.IsAuthorizedRequest.digital_twin_identifier:type_name -> indykite.identity.v1beta2.DigitalTwinIdentifier 3, // 1: indykite.authorization.v1beta1.IsAuthorizedRequest.resources:type_name -> indykite.authorization.v1beta1.IsAuthorizedRequest.Resource 7, // 2: indykite.authorization.v1beta1.IsAuthorizedResponse.decision_time:type_name -> google.protobuf.Timestamp 4, // 3: indykite.authorization.v1beta1.IsAuthorizedResponse.decisions:type_name -> indykite.authorization.v1beta1.IsAuthorizedResponse.DecisionsEntry @@ -464,6 +490,9 @@ func file_indykite_authorization_v1beta1_authorization_service_proto_init() { } } } + file_indykite_authorization_v1beta1_authorization_service_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*IsAuthorizedRequest_DigitalTwinIdentifier)(nil), + } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ diff --git a/gen/indykite/authorization/v1beta1/authorization_service.pb.validate.go b/gen/indykite/authorization/v1beta1/authorization_service.pb.validate.go index 29a0c6f..61119cb 100644 --- a/gen/indykite/authorization/v1beta1/authorization_service.pb.validate.go +++ b/gen/indykite/authorization/v1beta1/authorization_service.pb.validate.go @@ -57,46 +57,6 @@ func (m *IsAuthorizedRequest) validate(all bool) error { var errors []error - if m.GetSubject() == nil { - err := IsAuthorizedRequestValidationError{ - field: "Subject", - reason: "value is required", - } - if !all { - return err - } - errors = append(errors, err) - } - - if all { - switch v := interface{}(m.GetSubject()).(type) { - case interface{ ValidateAll() error }: - if err := v.ValidateAll(); err != nil { - errors = append(errors, IsAuthorizedRequestValidationError{ - field: "Subject", - reason: "embedded message failed validation", - cause: err, - }) - } - case interface{ Validate() error }: - if err := v.Validate(); err != nil { - errors = append(errors, IsAuthorizedRequestValidationError{ - field: "Subject", - reason: "embedded message failed validation", - cause: err, - }) - } - } - } else if v, ok := interface{}(m.GetSubject()).(interface{ Validate() error }); ok { - if err := v.Validate(); err != nil { - return IsAuthorizedRequestValidationError{ - field: "Subject", - reason: "embedded message failed validation", - cause: err, - } - } - } - if l := len(m.GetResources()); l < 1 || l > 32 { err := IsAuthorizedRequestValidationError{ field: "Resources", @@ -180,6 +140,62 @@ func (m *IsAuthorizedRequest) validate(all bool) error { } + switch m.Subject.(type) { + + case *IsAuthorizedRequest_DigitalTwinIdentifier: + + if m.GetDigitalTwinIdentifier() == nil { + err := IsAuthorizedRequestValidationError{ + field: "DigitalTwinIdentifier", + reason: "value is required", + } + if !all { + return err + } + errors = append(errors, err) + } + + if all { + switch v := interface{}(m.GetDigitalTwinIdentifier()).(type) { + case interface{ ValidateAll() error }: + if err := v.ValidateAll(); err != nil { + errors = append(errors, IsAuthorizedRequestValidationError{ + field: "DigitalTwinIdentifier", + reason: "embedded message failed validation", + cause: err, + }) + } + case interface{ Validate() error }: + if err := v.Validate(); err != nil { + errors = append(errors, IsAuthorizedRequestValidationError{ + field: "DigitalTwinIdentifier", + reason: "embedded message failed validation", + cause: err, + }) + } + } + } else if v, ok := interface{}(m.GetDigitalTwinIdentifier()).(interface{ Validate() error }); ok { + if err := v.Validate(); err != nil { + return IsAuthorizedRequestValidationError{ + field: "DigitalTwinIdentifier", + reason: "embedded message failed validation", + cause: err, + } + } + } + + default: + err := IsAuthorizedRequestValidationError{ + field: "Subject", + reason: "value is required", + } + if !all { + return err + } + errors = append(errors, err) + + } + if len(errors) > 0 { return IsAuthorizedRequestMultiError(errors) } diff --git a/gen/indykite/authorization/v1beta1/authorization_service_grpc.pb.go b/gen/indykite/authorization/v1beta1/authorization_service_grpc.pb.go index 0a6647f..b9834b5 100644 --- a/gen/indykite/authorization/v1beta1/authorization_service_grpc.pb.go +++ b/gen/indykite/authorization/v1beta1/authorization_service_grpc.pb.go @@ -8,6 +8,7 @@ package authorizationv1beta1 import ( context "context" + grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" diff --git a/gen/indykite/config/v1beta1/config_management_api.pb.go b/gen/indykite/config/v1beta1/config_management_api.pb.go index 4fb6350..65d60ed 100644 --- a/gen/indykite/config/v1beta1/config_management_api.pb.go +++ b/gen/indykite/config/v1beta1/config_management_api.pb.go @@ -21,13 +21,15 @@ package configv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" - reflect "reflect" - sync "sync" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/config/v1beta1/config_management_api_grpc.pb.go b/gen/indykite/config/v1beta1/config_management_api_grpc.pb.go index adefdbd..599078d 100644 --- a/gen/indykite/config/v1beta1/config_management_api_grpc.pb.go +++ b/gen/indykite/config/v1beta1/config_management_api_grpc.pb.go @@ -8,6 +8,7 @@ package configv1beta1 import ( context "context" + grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" diff --git a/gen/indykite/config/v1beta1/model.pb.go b/gen/indykite/config/v1beta1/model.pb.go index 0fa1c61..2c0044e 100644 --- a/gen/indykite/config/v1beta1/model.pb.go +++ b/gen/indykite/config/v1beta1/model.pb.go @@ -21,16 +21,19 @@ package configv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta11 "github.com/indykite/jarvis-sdk-go/gen/indykite/knowledge_graph/v1beta1" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" durationpb "google.golang.org/protobuf/types/known/durationpb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" - reflect "reflect" - sync "sync" + + v1beta11 "github.com/indykite/jarvis-sdk-go/gen/indykite/knowledge_graph/v1beta1" + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/events/v1beta1/events.pb.go b/gen/indykite/events/v1beta1/events.pb.go index bcdb4bd..80106e2 100644 --- a/gen/indykite/events/v1beta1/events.pb.go +++ b/gen/indykite/events/v1beta1/events.pb.go @@ -21,13 +21,15 @@ package eventsv1beta1 import ( - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + latlng "google.golang.org/genproto/googleapis/type/latlng" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" ) const ( diff --git a/gen/indykite/identity/v1beta1/attributes.pb.go b/gen/indykite/identity/v1beta1/attributes.pb.go index cf6e244..30c3077 100644 --- a/gen/indykite/identity/v1beta1/attributes.pb.go +++ b/gen/indykite/identity/v1beta1/attributes.pb.go @@ -21,13 +21,16 @@ package identityv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( @@ -175,24 +178,25 @@ func (x *Schema) GetAttributeName() string { // The location consist of three component: // 1. Schema namespace where the property is defined. // Some examples like: -// "schema": "http://schema.org/", -// "bibo": "http://purl.org/ontology/bibo/", -// "dc": "http://purl.org/dc/elements/1.1/", -// "dcat": "http://www.w3.org/ns/dcat#", -// "dct": "http://purl.org/dc/terms/", -// "dcterms": "http://purl.org/dc/terms/", -// "dctype": "http://purl.org/dc/dcmitype/", -// "eli": "http://data.europa.eu/eli/ontology#", -// "foaf": "http://xmlns.com/foaf/0.1/", -// "owl": "http://www.w3.org/2002/07/owl#", -// "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", -// "rdfa": "http://www.w3.org/ns/rdfa#", -// "rdfs": "http://www.w3.org/2000/01/rdf-schema#", -// "skos": "http://www.w3.org/2004/02/skos/core#", -// "snomed": "http://purl.bioontology.org/ontology/SNOMEDCT/", -// "void": "http://rdfs.org/ns/void#", -// "xsd": "http://www.w3.org/2001/XMLSchema#", -// "xsd1": "hhttp://www.w3.org/2001/XMLSchema#" +// +// "schema": "http://schema.org/", +// "bibo": "http://purl.org/ontology/bibo/", +// "dc": "http://purl.org/dc/elements/1.1/", +// "dcat": "http://www.w3.org/ns/dcat#", +// "dct": "http://purl.org/dc/terms/", +// "dcterms": "http://purl.org/dc/terms/", +// "dctype": "http://purl.org/dc/dcmitype/", +// "eli": "http://data.europa.eu/eli/ontology#", +// "foaf": "http://xmlns.com/foaf/0.1/", +// "owl": "http://www.w3.org/2002/07/owl#", +// "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", +// "rdfa": "http://www.w3.org/ns/rdfa#", +// "rdfs": "http://www.w3.org/2000/01/rdf-schema#", +// "skos": "http://www.w3.org/2004/02/skos/core#", +// "snomed": "http://purl.bioontology.org/ontology/SNOMEDCT/", +// "void": "http://rdfs.org/ns/void#", +// "xsd": "http://www.w3.org/2001/XMLSchema#", +// "xsd1": "hhttp://www.w3.org/2001/XMLSchema#" // // 2. Type definition withing the names space. // 3. Exact property name, it may be unambiguous if there is one definition but ambiguous without diff --git a/gen/indykite/identity/v1beta1/authenteq.pb.go b/gen/indykite/identity/v1beta1/authenteq.pb.go index 1ff261c..ce8b39b 100644 --- a/gen/indykite/identity/v1beta1/authenteq.pb.go +++ b/gen/indykite/identity/v1beta1/authenteq.pb.go @@ -21,10 +21,11 @@ package identityv1beta1 import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" ) const ( diff --git a/gen/indykite/identity/v1beta1/document.pb.go b/gen/indykite/identity/v1beta1/document.pb.go index 1f05944..20b770b 100644 --- a/gen/indykite/identity/v1beta1/document.pb.go +++ b/gen/indykite/identity/v1beta1/document.pb.go @@ -21,12 +21,14 @@ package identityv1beta1 import ( - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" ) const ( diff --git a/gen/indykite/identity/v1beta1/identity_management_api.pb.go b/gen/indykite/identity/v1beta1/identity_management_api.pb.go index e9de0d7..b1f8d2c 100644 --- a/gen/indykite/identity/v1beta1/identity_management_api.pb.go +++ b/gen/indykite/identity/v1beta1/identity_management_api.pb.go @@ -23,16 +23,19 @@ package identityv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" - _ "google.golang.org/genproto/googleapis/api/annotations" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" structpb "google.golang.org/protobuf/types/known/structpb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" + _ "google.golang.org/genproto/googleapis/api/annotations" ) const ( diff --git a/gen/indykite/identity/v1beta1/identity_management_api_grpc.pb.go b/gen/indykite/identity/v1beta1/identity_management_api_grpc.pb.go index 989b1db..5c47cdd 100644 --- a/gen/indykite/identity/v1beta1/identity_management_api_grpc.pb.go +++ b/gen/indykite/identity/v1beta1/identity_management_api_grpc.pb.go @@ -8,6 +8,7 @@ package identityv1beta1 import ( context "context" + grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" diff --git a/gen/indykite/identity/v1beta1/import.pb.go b/gen/indykite/identity/v1beta1/import.pb.go index eec9a10..bb511f4 100644 --- a/gen/indykite/identity/v1beta1/import.pb.go +++ b/gen/indykite/identity/v1beta1/import.pb.go @@ -21,11 +21,13 @@ package identityv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/identity/v1beta1/model.pb.go b/gen/indykite/identity/v1beta1/model.pb.go index 5b83ac5..9d91656 100644 --- a/gen/indykite/identity/v1beta1/model.pb.go +++ b/gen/indykite/identity/v1beta1/model.pb.go @@ -23,14 +23,17 @@ package identityv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" structpb "google.golang.org/protobuf/types/known/structpb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/identity/v1beta2/attributes.ext.go b/gen/indykite/identity/v1beta2/attributes.ext.go new file mode 100644 index 0000000..f97379b --- /dev/null +++ b/gen/indykite/identity/v1beta2/attributes.ext.go @@ -0,0 +1,207 @@ +// Copyright (c) 2023 IndyKite +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package identityv1beta2 + +import ( + "errors" + "fmt" + + "google.golang.org/protobuf/proto" + + objects "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" +) + +type PropertyIssuerPrefix string + +const ( + PropertyRawPrefix PropertyIssuerPrefix = "raw" + PropertyApplicationPrefix PropertyIssuerPrefix = "app" + PropertyAppSpacePrefix PropertyIssuerPrefix = "asp" +) + +type PropertyBatchOperations []*PropertyBatchOperation + +func (PropertyBatchOperations) idInArray(haystack []string, needle string) bool { + for _, v := range haystack { + if v == needle { + return true + } + } + + return false +} + +func (x *Property) HasSameDefinition(other *Property) bool { + if other == nil || other.Definition == nil { + return false + } + return proto.Equal(x.GetDefinition(), other.GetDefinition()) +} + +func (x *Property) GetStringValue() (string, bool) { + if val, ok := x.Value.(*Property_ObjectValue); ok { + if objVal, ok := val.ObjectValue.GetValue().(*objects.Value_StringValue); ok { + return objVal.StringValue, true + } + } + return "", false +} + +func (x *Property) GetIntValue() (int64, bool) { + if val, ok := x.Value.(*Property_ObjectValue); ok { + if objVal, ok := val.ObjectValue.GetValue().(*objects.Value_IntegerValue); ok { + return objVal.IntegerValue, true + } + } + return 0, false +} + +func (x *Property) GetAnyValue(msg proto.Message) error { + if val, ok := x.Value.(*Property_ObjectValue); ok { + if anyVal, ok := val.ObjectValue.GetValue().(*objects.Value_AnyValue); ok { + return anyVal.AnyValue.UnmarshalTo(msg) + } else if _, ok = val.ObjectValue.GetValue().(*objects.Value_NullValue); ok { + return nil + } + } + return errors.New("invalid AnyPB value") +} + +func (x *Property) GetMapValue() (val map[string]interface{}, err error) { + if val, ok := x.Value.(*Property_ObjectValue); ok { + if mapVal, ok := val.ObjectValue.GetValue().(*objects.Value_MapValue); ok { + return objects.ToMap(mapVal.MapValue.Fields) + } else if _, ok = val.ObjectValue.GetValue().(*objects.Value_NullValue); ok { + return nil, nil + } + } + return nil, errors.New("invalid map value") +} + +// validateValue checks if an operation value is properly set. +// +// It checks if the property values is not nil. +func (PropertyBatchOperations) validateValue(value isProperty_Value, enableNil bool) error { + switch propertyValue := value.(type) { + case nil: + if !enableNil { + return errors.New("value cannot be nil") + } + case *Property_ObjectValue: + if propertyValue.ObjectValue == nil || propertyValue.ObjectValue.Value == nil { + return errors.New("object value must be specified") + } + case *Property_ReferenceValue: + if len(propertyValue.ReferenceValue) == 0 { + return errors.New("reference value must be specified") + } + default: + return errors.New("invalid value type") + } + return nil +} + +func (PropertyBatchOperations) validateMeta(meta *PropertyMetadata) error { + if meta == nil { + return nil + } + + if meta.AssuranceLevel > AssuranceLevel_ASSURANCE_LEVEL_LOW && meta.Verifier == "" { + return errors.New("verifier is required when assurance level is Substantial or more") + } + if meta.Verifier != "" && meta.AssuranceLevel < AssuranceLevel_ASSURANCE_LEVEL_SUBSTANTIAL { + return errors.New("assurance level must be Substantial or more when verifier is set") + } + if meta.Verifier == "" && meta.VerificationTime != nil { + return errors.New("verification time must be set together with verifier") + } + + return nil +} + +// Validate checks the PropertyBatchOperations values. All public calls are considered non-trusted. +// +// It checks if the operations represent a valid collection of property updates. +func (x PropertyBatchOperations) Validate() error { + _, _, err := x.PreValidate() + return err +} + +// PreValidate checks the PropertyBatchOperations values. All public calls are considered non-trusted. +// +// It checks if the operations represent a valid collection of property updates. +func (x PropertyBatchOperations) PreValidate() ([]string, []string, error) { + if len(x) == 0 { + return nil, nil, errors.New("empty batch operation") + } + + // This logic cannot be really tight to internal property logic, because PreValidate is used also in public part + var replaced, removed []string + for i, v := range x { + err := v.Validate() + if err != nil { + return nil, nil, fmt.Errorf("invalid operation at index %d: %v", i, err) + } + switch bo := v.Operation.(type) { + case *PropertyBatchOperation_Add: + if bo.Add == nil || bo.Add.Definition == nil { + return nil, nil, fmt.Errorf("invalid add operation at position: %d", i) + } + if bo.Add.Id != "" { + return nil, nil, fmt.Errorf("cannot set custom ID for add operation at position: %d", i) + } + if err := x.validateMeta(bo.Add.Meta); err != nil { + return nil, nil, fmt.Errorf("%s at position: %d", err.Error(), i) + } + if err := x.validateValue(bo.Add.Value, false); err != nil { + return nil, nil, fmt.Errorf("%s at position: %d", err.Error(), i) + } + case *PropertyBatchOperation_Replace: + if bo.Replace == nil || bo.Replace.Id == "" { + return nil, nil, fmt.Errorf("invalid replace operation at position: %d", i) + } + if bo.Replace.Value == nil && bo.Replace.Meta == nil { + return nil, nil, fmt.Errorf("at least Value or Meta must be set at position: %d", i) + } + if err := x.validateValue(bo.Replace.Value, true); err != nil { + return nil, nil, fmt.Errorf("%s at position: %d", err.Error(), i) + } + if err := x.validateMeta(bo.Replace.Meta); err != nil { + return nil, nil, fmt.Errorf("%s at position: %d", err.Error(), i) + } + if x.idInArray(replaced, bo.Replace.Id) { + return nil, nil, fmt.Errorf("replacing same property more than once is not allowed at position: %d", i) + } + if x.idInArray(removed, bo.Replace.Id) { + return nil, nil, fmt.Errorf("replacing property previously deleted is not allowed at position: %d", i) + } + replaced = append(replaced, bo.Replace.Id) + case *PropertyBatchOperation_Remove: + if bo.Remove == nil || bo.Remove.Id == "" { + return nil, nil, fmt.Errorf("invalid remove operation at position: %d", i) + } + if x.idInArray(replaced, bo.Remove.Id) { + return nil, nil, fmt.Errorf("deleting previously replaced property is not allowed at position: %d", i) + } + if x.idInArray(removed, bo.Remove.Id) { + return nil, nil, fmt.Errorf("deleting property multiple times is not allowed at position: %d", i) + } + removed = append(removed, bo.Remove.Id) + default: + return nil, nil, fmt.Errorf("invalid operation at position: %d", i) + } + } + return replaced, removed, nil +} diff --git a/gen/indykite/identity/v1beta2/attributes.pb.go b/gen/indykite/identity/v1beta2/attributes.pb.go index b663ac5..0be796e 100644 --- a/gen/indykite/identity/v1beta2/attributes.pb.go +++ b/gen/indykite/identity/v1beta2/attributes.pb.go @@ -21,13 +21,16 @@ package identityv1beta2 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( @@ -175,24 +178,25 @@ func (x *Schema) GetAttributeName() string { // The location consist of three component: // 1. Schema namespace where the property is defined. // Some examples like: -// "schema": "http://schema.org/", -// "bibo": "http://purl.org/ontology/bibo/", -// "dc": "http://purl.org/dc/elements/1.1/", -// "dcat": "http://www.w3.org/ns/dcat#", -// "dct": "http://purl.org/dc/terms/", -// "dcterms": "http://purl.org/dc/terms/", -// "dctype": "http://purl.org/dc/dcmitype/", -// "eli": "http://data.europa.eu/eli/ontology#", -// "foaf": "http://xmlns.com/foaf/0.1/", -// "owl": "http://www.w3.org/2002/07/owl#", -// "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", -// "rdfa": "http://www.w3.org/ns/rdfa#", -// "rdfs": "http://www.w3.org/2000/01/rdf-schema#", -// "skos": "http://www.w3.org/2004/02/skos/core#", -// "snomed": "http://purl.bioontology.org/ontology/SNOMEDCT/", -// "void": "http://rdfs.org/ns/void#", -// "xsd": "http://www.w3.org/2001/XMLSchema#", -// "xsd1": "hhttp://www.w3.org/2001/XMLSchema#" +// +// "schema": "http://schema.org/", +// "bibo": "http://purl.org/ontology/bibo/", +// "dc": "http://purl.org/dc/elements/1.1/", +// "dcat": "http://www.w3.org/ns/dcat#", +// "dct": "http://purl.org/dc/terms/", +// "dcterms": "http://purl.org/dc/terms/", +// "dctype": "http://purl.org/dc/dcmitype/", +// "eli": "http://data.europa.eu/eli/ontology#", +// "foaf": "http://xmlns.com/foaf/0.1/", +// "owl": "http://www.w3.org/2002/07/owl#", +// "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", +// "rdfa": "http://www.w3.org/ns/rdfa#", +// "rdfs": "http://www.w3.org/2000/01/rdf-schema#", +// "skos": "http://www.w3.org/2004/02/skos/core#", +// "snomed": "http://purl.bioontology.org/ontology/SNOMEDCT/", +// "void": "http://rdfs.org/ns/void#", +// "xsd": "http://www.w3.org/2001/XMLSchema#", +// "xsd1": "hhttp://www.w3.org/2001/XMLSchema#" // // 2. Type definition withing the names space. // 3. Exact property name, it may be unambiguous if there is one definition but ambiguous without diff --git a/gen/indykite/identity/v1beta2/authenteq.pb.go b/gen/indykite/identity/v1beta2/authenteq.pb.go index 6ae6446..dadf275 100644 --- a/gen/indykite/identity/v1beta2/authenteq.pb.go +++ b/gen/indykite/identity/v1beta2/authenteq.pb.go @@ -21,10 +21,11 @@ package identityv1beta2 import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" ) const ( diff --git a/gen/indykite/identity/v1beta2/consent.pb.go b/gen/indykite/identity/v1beta2/consent.pb.go index 6c56966..3324377 100644 --- a/gen/indykite/identity/v1beta2/consent.pb.go +++ b/gen/indykite/identity/v1beta2/consent.pb.go @@ -21,11 +21,12 @@ package identityv1beta2 import ( + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" ) const ( diff --git a/gen/indykite/identity/v1beta2/doc.go b/gen/indykite/identity/v1beta2/doc.go new file mode 100644 index 0000000..9e33405 --- /dev/null +++ b/gen/indykite/identity/v1beta2/doc.go @@ -0,0 +1,16 @@ +// Copyright (c) 2022 IndyKite +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package identityv1beta2 is generated from proto package. +package identityv1beta2 diff --git a/gen/indykite/identity/v1beta2/document.pb.go b/gen/indykite/identity/v1beta2/document.pb.go index b0af613..6a52b71 100644 --- a/gen/indykite/identity/v1beta2/document.pb.go +++ b/gen/indykite/identity/v1beta2/document.pb.go @@ -21,12 +21,14 @@ package identityv1beta2 import ( - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" ) const ( diff --git a/gen/indykite/identity/v1beta2/identity_management_api.pb.go b/gen/indykite/identity/v1beta2/identity_management_api.pb.go index f6b7ca4..59337bc 100644 --- a/gen/indykite/identity/v1beta2/identity_management_api.pb.go +++ b/gen/indykite/identity/v1beta2/identity_management_api.pb.go @@ -23,16 +23,19 @@ package identityv1beta2 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" - _ "google.golang.org/genproto/googleapis/api/annotations" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" structpb "google.golang.org/protobuf/types/known/structpb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" + _ "google.golang.org/genproto/googleapis/api/annotations" ) const ( diff --git a/gen/indykite/identity/v1beta2/identity_management_api_grpc.pb.go b/gen/indykite/identity/v1beta2/identity_management_api_grpc.pb.go index b747da0..c71af57 100644 --- a/gen/indykite/identity/v1beta2/identity_management_api_grpc.pb.go +++ b/gen/indykite/identity/v1beta2/identity_management_api_grpc.pb.go @@ -8,6 +8,7 @@ package identityv1beta2 import ( context "context" + grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" diff --git a/gen/indykite/identity/v1beta2/import.pb.go b/gen/indykite/identity/v1beta2/import.pb.go index 4690d67..981b136 100644 --- a/gen/indykite/identity/v1beta2/import.pb.go +++ b/gen/indykite/identity/v1beta2/import.pb.go @@ -21,11 +21,13 @@ package identityv1beta2 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/identity/v1beta2/model.pb.go b/gen/indykite/identity/v1beta2/model.pb.go index 6680c62..2d4f448 100644 --- a/gen/indykite/identity/v1beta2/model.pb.go +++ b/gen/indykite/identity/v1beta2/model.pb.go @@ -23,14 +23,17 @@ package identityv1beta2 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" structpb "google.golang.org/protobuf/types/known/structpb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/identity/v1beta2/readid.pb.go b/gen/indykite/identity/v1beta2/readid.pb.go index efaca7a..f739bc1 100644 --- a/gen/indykite/identity/v1beta2/readid.pb.go +++ b/gen/indykite/identity/v1beta2/readid.pb.go @@ -21,10 +21,11 @@ package identityv1beta2 import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" ) const ( diff --git a/gen/indykite/ingest/v1beta1/ingest_api.pb.go b/gen/indykite/ingest/v1beta1/ingest_api.pb.go index 2512cc1..bb015e5 100644 --- a/gen/indykite/ingest/v1beta1/ingest_api.pb.go +++ b/gen/indykite/ingest/v1beta1/ingest_api.pb.go @@ -23,12 +23,14 @@ package ingestv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" + reflect "reflect" + sync "sync" + status "google.golang.org/genproto/googleapis/rpc/status" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" - reflect "reflect" - sync "sync" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/ingest/v1beta1/ingest_api_grpc.pb.go b/gen/indykite/ingest/v1beta1/ingest_api_grpc.pb.go index 2b756a5..4e1a55d 100644 --- a/gen/indykite/ingest/v1beta1/ingest_api_grpc.pb.go +++ b/gen/indykite/ingest/v1beta1/ingest_api_grpc.pb.go @@ -8,6 +8,7 @@ package ingestv1beta1 import ( context "context" + grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" diff --git a/gen/indykite/ingest/v1beta1/model.pb.go b/gen/indykite/ingest/v1beta1/model.pb.go index b20478c..81ad08d 100644 --- a/gen/indykite/ingest/v1beta1/model.pb.go +++ b/gen/indykite/ingest/v1beta1/model.pb.go @@ -21,12 +21,15 @@ package ingestv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" sync "sync" + + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + + v1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/knowledge_graph/v1beta1/policy.pb.go b/gen/indykite/knowledge_graph/v1beta1/policy.pb.go index 93ead15..724d028 100644 --- a/gen/indykite/knowledge_graph/v1beta1/policy.pb.go +++ b/gen/indykite/knowledge_graph/v1beta1/policy.pb.go @@ -21,13 +21,16 @@ package knowledge_graphv1beta1 import ( - _ "github.com/envoyproxy/protoc-gen-validate/validate" - v1beta2 "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" + reflect "reflect" + sync "sync" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" + + v1beta2 "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" + + _ "github.com/envoyproxy/protoc-gen-validate/validate" ) const ( diff --git a/gen/indykite/objects/v1beta1/struct.pb.go b/gen/indykite/objects/v1beta1/struct.pb.go index 5967a70..c70e3a2 100644 --- a/gen/indykite/objects/v1beta1/struct.pb.go +++ b/gen/indykite/objects/v1beta1/struct.pb.go @@ -21,6 +21,9 @@ package objectsv1beta1 import ( + reflect "reflect" + sync "sync" + latlng "google.golang.org/genproto/googleapis/type/latlng" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" @@ -28,8 +31,6 @@ import ( durationpb "google.golang.org/protobuf/types/known/durationpb" structpb "google.golang.org/protobuf/types/known/structpb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" - reflect "reflect" - sync "sync" ) const ( diff --git a/gen/indykite/objects/v1beta1/struct.pb.validate.go b/gen/indykite/objects/v1beta1/struct.pb.validate.go index 50d3001..7d04e8d 100644 --- a/gen/indykite/objects/v1beta1/struct.pb.validate.go +++ b/gen/indykite/objects/v1beta1/struct.pb.validate.go @@ -17,7 +17,6 @@ import ( "unicode/utf8" "google.golang.org/protobuf/types/known/anypb" - structpb "google.golang.org/protobuf/types/known/structpb" ) diff --git a/identity/authorization.go b/identity/authorization.go index 6e29161..1939725 100644 --- a/identity/authorization.go +++ b/identity/authorization.go @@ -20,7 +20,7 @@ import ( "google.golang.org/grpc" "github.com/indykite/jarvis-sdk-go/errors" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" objects "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" ) @@ -73,10 +73,10 @@ func (c *Client) IsAuthorizedByStringExternalID( opts ...grpc.CallOption, ) (*identitypb.IsAuthorizedResponse, error) { return c.IsAuthorizedWithRawRequest(ctx, &identitypb.IsAuthorizedRequest{ - Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_Property{ - Property: &identitypb.Property{ - Definition: &identitypb.PropertyDefinition{Property: externalIDProperty}, - Value: &identitypb.Property_ObjectValue{ObjectValue: objects.String(externalID)}, + Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_PropertyFilter{ + PropertyFilter: &identitypb.PropertyFilter{ + Type: externalIDProperty, + Value: objects.String(externalID), }, }}, Actions: actions, @@ -94,10 +94,10 @@ func (c *Client) IsAuthorizedByNumericExternalID( opts ...grpc.CallOption, ) (*identitypb.IsAuthorizedResponse, error) { return c.IsAuthorizedWithRawRequest(ctx, &identitypb.IsAuthorizedRequest{ - Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_Property{ - Property: &identitypb.Property{ - Definition: &identitypb.PropertyDefinition{Property: externalIDProperty}, - Value: &identitypb.Property_ObjectValue{ObjectValue: objects.Int64(externalID)}, + Subject: &identitypb.DigitalTwinIdentifier{Filter: &identitypb.DigitalTwinIdentifier_PropertyFilter{ + PropertyFilter: &identitypb.PropertyFilter{ + Type: externalIDProperty, + Value: objects.Int64(externalID), }, }}, Actions: actions, @@ -114,8 +114,7 @@ func (c *Client) IsAuthorizedWithRawRequest( return nil, errors.NewInvalidArgumentErrorWithCause(err, "unable to call IsAuthorized client endpoint") } - switch sub := req.Subject.Filter.(type) { - case *identitypb.DigitalTwinIdentifier_AccessToken: + if sub, ok := req.Subject.Filter.(*identitypb.DigitalTwinIdentifier_AccessToken); ok { if err := verifyTokenFormat(sub.AccessToken); err != nil { return nil, err } diff --git a/identity/consent.go b/identity/consent.go index 6c049c5..cc1b442 100644 --- a/identity/consent.go +++ b/identity/consent.go @@ -20,20 +20,20 @@ import ( "google.golang.org/grpc" "github.com/indykite/jarvis-sdk-go/errors" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) func (c *Client) CheckConsentChallenge( ctx context.Context, - req *identitypb.CheckConsentChallengeRequest, + req *identitypb.CheckOAuth2ConsentChallengeRequest, opts ...grpc.CallOption, -) (*identitypb.CheckConsentChallengeResponse, error) { +) (*identitypb.CheckOAuth2ConsentChallengeResponse, error) { if err := req.Validate(); err != nil { return nil, errors.NewInvalidArgumentErrorWithCause(err, "unable to call CheckConsentChallenge") } ctx = insertMetadata(ctx, c.xMetadata) - resp, err := c.client.CheckConsentChallenge(ctx, req, opts...) + resp, err := c.client.CheckOAuth2ConsentChallenge(ctx, req, opts...) if s := errors.FromError(err); s != nil { return nil, s @@ -43,15 +43,15 @@ func (c *Client) CheckConsentChallenge( func (c *Client) CreateConsentVerifier( ctx context.Context, - req *identitypb.CreateConsentVerifierRequest, + req *identitypb.CreateOAuth2ConsentVerifierRequest, opts ...grpc.CallOption, -) (*identitypb.CreateConsentVerifierResponse, error) { +) (*identitypb.CreateOAuth2ConsentVerifierResponse, error) { if err := req.Validate(); err != nil { return nil, errors.NewInvalidArgumentErrorWithCause(err, "unable to call CreateConsentVerifier") } ctx = insertMetadata(ctx, c.xMetadata) - resp, err := c.client.CreateConsentVerifier(ctx, req, opts...) + resp, err := c.client.CreateOAuth2ConsentVerifier(ctx, req, opts...) if s := errors.FromError(err); s != nil { return nil, s diff --git a/identity/digital_twin.go b/identity/digital_twin.go index e9cbd98..91ee214 100644 --- a/identity/digital_twin.go +++ b/identity/digital_twin.go @@ -21,7 +21,7 @@ import ( "google.golang.org/grpc/codes" "github.com/indykite/jarvis-sdk-go/errors" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" objects "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" ) @@ -32,9 +32,6 @@ import ( // This is a protected operation and it can be accessed only with valid agent credentials! func (c *Client) StartEmailVerification(ctx context.Context, digitalTwin *identitypb.DigitalTwin, email string, attributes *objects.MapValue, opts ...grpc.CallOption) error { - if _, _, err := digitalTwin.Verify(); err != nil { - return errors.NewInvalidArgumentError(err.Error()) - } req := &identitypb.StartDigitalTwinEmailVerificationRequest{ DigitalTwin: digitalTwin, Email: email, @@ -128,9 +125,6 @@ func (c *Client) ChangePasswordOfDigitalTwin(ctx context.Context, newPassword string, opts ...grpc.CallOption, ) (*identitypb.ChangePasswordResponse, error) { - if _, _, err := digitalTwin.Verify(); err != nil { - return nil, errors.NewInvalidArgumentError(err.Error()) - } if len(newPassword) <= 4 { return nil, errors.NewInvalidArgumentError("password is too short") } @@ -172,10 +166,6 @@ func (c *Client) GetDigitalTwin(ctx context.Context, properties []*identitypb.PropertyMask, opts ...grpc.CallOption, ) (*identitypb.GetDigitalTwinResponse, error) { - if _, _, err := digitalTwin.Verify(); err != nil { - return nil, errors.NewInvalidArgumentError(err.Error()) - } - return c.getDigitalTwinWithProperties(ctx, &identitypb.DigitalTwinIdentifier{ Filter: &identitypb.DigitalTwinIdentifier_DigitalTwin{DigitalTwin: digitalTwin}, }, properties, opts...) @@ -202,7 +192,7 @@ func (c *Client) patchDigitalTwinProperties(ctx context.Context, forceDelete bool, opts ...grpc.CallOption, ) ([]*identitypb.BatchOperationResult, error) { - if err := identitypb.PropertyBatchOperations(operations).Validate(false); err != nil { + if err := identitypb.PropertyBatchOperations(operations).Validate(); err != nil { return nil, errors.NewInvalidArgumentErrorWithCause(err, "invalid patch request") } req := &identitypb.PatchDigitalTwinRequest{ @@ -230,10 +220,6 @@ func (c *Client) PatchDigitalTwin(ctx context.Context, forceDelete bool, opts ...grpc.CallOption, ) ([]*identitypb.BatchOperationResult, error) { - if _, _, err := digitalTwin.Verify(); err != nil { - return nil, errors.NewInvalidArgumentError(err.Error()) - } - return c.patchDigitalTwinProperties(ctx, &identitypb.DigitalTwinIdentifier{ Filter: &identitypb.DigitalTwinIdentifier_DigitalTwin{DigitalTwin: digitalTwin}, }, operations, forceDelete, opts...) @@ -278,10 +264,6 @@ func (c *Client) DeleteDigitalTwin(ctx context.Context, digitalTwin *identitypb.DigitalTwin, opts ...grpc.CallOption, ) (*identitypb.DigitalTwin, error) { - if _, _, err := digitalTwin.Verify(); err != nil { - return nil, errors.NewInvalidArgumentError(err.Error()) - } - return c.deleteDigitalTwinByIdentifier(ctx, &identitypb.DigitalTwinIdentifier{ Filter: &identitypb.DigitalTwinIdentifier_DigitalTwin{DigitalTwin: digitalTwin}, }, opts...) diff --git a/identity/enrich_token.go b/identity/enrich_token.go index c099323..a4f4e17 100644 --- a/identity/enrich_token.go +++ b/identity/enrich_token.go @@ -20,7 +20,7 @@ import ( "google.golang.org/grpc" "github.com/indykite/jarvis-sdk-go/errors" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) func (c *Client) EnrichToken( diff --git a/identity/identity_client.go b/identity/identity_client.go index ad001fc..3b6e1c0 100644 --- a/identity/identity_client.go +++ b/identity/identity_client.go @@ -21,7 +21,7 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/metadata" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" api "github.com/indykite/jarvis-sdk-go/grpc" ) diff --git a/identity/invitation.go b/identity/invitation.go index 28cb06e..94f3523 100644 --- a/identity/invitation.go +++ b/identity/invitation.go @@ -18,12 +18,10 @@ import ( "context" "time" - guuid "github.com/google/uuid" - "github.com/pborman/uuid" "google.golang.org/grpc" "github.com/indykite/jarvis-sdk-go/errors" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" objects "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" ) @@ -97,7 +95,7 @@ func (c *Client) CancelInvitation(ctx context.Context, referenceID string, opts // CreateEmailInvitation receive all properties for digital twin. func (c *Client) CreateEmailInvitation(ctx context.Context, - invitee string, tenantID interface{}, referenceID string, + invitee string, tenantID string, referenceID string, expireTime, inviteAtTime time.Time, messageAttributes map[string]interface{}, opts ...grpc.CallOption) error { var request = &identitypb.CreateInvitationRequest{ @@ -107,22 +105,7 @@ func (c *Client) CreateEmailInvitation(ctx context.Context, }, InviteAtTime: optionalTime(inviteAtTime), ExpireTime: optionalTime(expireTime), - } - - switch v := tenantID.(type) { - case string: - var err error - request.TenantId, err = ParseUUID(v) - if err != nil { - return err - } - case []byte: - if uuid.UUID(v).Variant() != guuid.RFC4122 { - return errors.NewInvalidArgumentError("invalid UUID RFC4122 variant") - } - request.TenantId = v - default: - return errors.NewInvalidArgumentError("unsupported tenantID type") + TenantId: tenantID, } if len(messageAttributes) > 0 { diff --git a/identity/invitation_test.go b/identity/invitation_test.go index 4e045ad..e1db682 100644 --- a/identity/invitation_test.go +++ b/identity/invitation_test.go @@ -21,10 +21,10 @@ import ( "github.com/golang/mock/gomock" "google.golang.org/protobuf/types/known/timestamppb" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" objects "github.com/indykite/jarvis-sdk-go/gen/indykite/objects/v1beta1" "github.com/indykite/jarvis-sdk-go/identity" - midentity "github.com/indykite/jarvis-sdk-go/test/identity/v1beta1" + midentity "github.com/indykite/jarvis-sdk-go/test/identity/v1beta2" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -38,7 +38,7 @@ var _ = Describe("Invitation", func() { client, err := identity.NewTestClient(mockClient) Ω(err).To(Succeed()) - tenantID, err := identity.ParseUUID("696e6479-6b69-4465-8000-030100000002") + tenantID := "gid:AAAAA2luZHlraURlgAADDwAAAAE" Ω(err).To(Succeed()) now := time.Now().Add(time.Minute) @@ -56,7 +56,7 @@ var _ = Describe("Invitation", func() { err = client.CreateEmailInvitation(context.Background(), "test@example.com", - "696e6479-6b69-4465-8000-030100000002", + "gid:AAAAA2luZHlraURlgAADDwAAAAE", "my-reference", now.AddDate(0, 0, 7), now, map[string]interface{}{ diff --git a/oauth2/token.go b/oauth2/token.go index 5b932a9..474e893 100644 --- a/oauth2/token.go +++ b/oauth2/token.go @@ -23,7 +23,7 @@ import ( "google.golang.org/grpc" "google.golang.org/grpc/credentials/oauth" - identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" + identitypb "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" ) type ( diff --git a/test/identity/v1beta1/identity_management_api_mock.go b/test/identity/v1beta1/identity_management_api_mock.go index 9315c8a..97acce4 100644 --- a/test/identity/v1beta1/identity_management_api_mock.go +++ b/test/identity/v1beta1/identity_management_api_mock.go @@ -24,9 +24,10 @@ import ( reflect "reflect" gomock "github.com/golang/mock/gomock" - identityv1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" grpc "google.golang.org/grpc" metadata "google.golang.org/grpc/metadata" + + identityv1beta1 "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta1" ) // MockIdentityManagementAPIClient is a mock of IdentityManagementAPIClient interface. diff --git a/test/identity/v1beta2/identity_management_api_mock.go b/test/identity/v1beta2/identity_management_api_mock.go new file mode 100644 index 0000000..2ddbcb8 --- /dev/null +++ b/test/identity/v1beta2/identity_management_api_mock.go @@ -0,0 +1,1669 @@ +// Copyright (c) 2022 IndyKite +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +// Code generated by MockGen. DO NOT EDIT. +// Source: ./gen/indykite/identity/v1beta1/identity_management_api_grpc.pb.go + +// Package identity is a generated GoMock package. +package identity + +import ( + context "context" + reflect "reflect" + + gomock "github.com/golang/mock/gomock" + grpc "google.golang.org/grpc" + metadata "google.golang.org/grpc/metadata" + + identityv1beta2 "github.com/indykite/jarvis-sdk-go/gen/indykite/identity/v1beta2" +) + +// MockIdentityManagementAPIClient is a mock of IdentityManagementAPIClient interface. +type MockIdentityManagementAPIClient struct { + ctrl *gomock.Controller + recorder *MockIdentityManagementAPIClientMockRecorder +} + +// MockIdentityManagementAPIClientMockRecorder is the mock recorder for MockIdentityManagementAPIClient. +type MockIdentityManagementAPIClientMockRecorder struct { + mock *MockIdentityManagementAPIClient +} + +// NewMockIdentityManagementAPIClient creates a new mock instance. +func NewMockIdentityManagementAPIClient(ctrl *gomock.Controller) *MockIdentityManagementAPIClient { + mock := &MockIdentityManagementAPIClient{ctrl: ctrl} + mock.recorder = &MockIdentityManagementAPIClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIdentityManagementAPIClient) EXPECT() *MockIdentityManagementAPIClientMockRecorder { + return m.recorder +} + +// BatchGetDocuments mocks base method. +func (m *MockIdentityManagementAPIClient) BatchGetDocuments(ctx context.Context, in *identityv1beta2.BatchGetDocumentsRequest, opts ...grpc.CallOption) (identityv1beta2.IdentityManagementAPI_BatchGetDocumentsClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchGetDocuments", varargs...) + ret0, _ := ret[0].(identityv1beta2.IdentityManagementAPI_BatchGetDocumentsClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchGetDocuments indicates an expected call of BatchGetDocuments. +func (mr *MockIdentityManagementAPIClientMockRecorder) BatchGetDocuments(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetDocuments", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).BatchGetDocuments), varargs...) +} + +// CancelInvitation mocks base method. +func (m *MockIdentityManagementAPIClient) CancelInvitation(ctx context.Context, in *identityv1beta2.CancelInvitationRequest, opts ...grpc.CallOption) (*identityv1beta2.CancelInvitationResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelInvitation", varargs...) + ret0, _ := ret[0].(*identityv1beta2.CancelInvitationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelInvitation indicates an expected call of CancelInvitation. +func (mr *MockIdentityManagementAPIClientMockRecorder) CancelInvitation(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInvitation", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).CancelInvitation), varargs...) +} + +// ChangePassword mocks base method. +func (m *MockIdentityManagementAPIClient) ChangePassword(ctx context.Context, in *identityv1beta2.ChangePasswordRequest, opts ...grpc.CallOption) (*identityv1beta2.ChangePasswordResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ChangePassword", varargs...) + ret0, _ := ret[0].(*identityv1beta2.ChangePasswordResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangePassword indicates an expected call of ChangePassword. +func (mr *MockIdentityManagementAPIClientMockRecorder) ChangePassword(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePassword", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).ChangePassword), varargs...) +} + +// CheckOAuth2ConsentChallenge mocks base method. +func (m *MockIdentityManagementAPIClient) CheckOAuth2ConsentChallenge(ctx context.Context, in *identityv1beta2.CheckOAuth2ConsentChallengeRequest, opts ...grpc.CallOption) (*identityv1beta2.CheckOAuth2ConsentChallengeResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CheckOAuth2ConsentChallenge", varargs...) + ret0, _ := ret[0].(*identityv1beta2.CheckOAuth2ConsentChallengeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckOAuth2ConsentChallenge indicates an expected call of CheckOAuth2ConsentChallenge. +func (mr *MockIdentityManagementAPIClientMockRecorder) CheckOAuth2ConsentChallenge(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckOAuth2ConsentChallenge", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).CheckOAuth2ConsentChallenge), varargs...) +} + +// CheckInvitationState mocks base method. +func (m *MockIdentityManagementAPIClient) CheckInvitationState(ctx context.Context, in *identityv1beta2.CheckInvitationStateRequest, opts ...grpc.CallOption) (*identityv1beta2.CheckInvitationStateResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CheckInvitationState", varargs...) + ret0, _ := ret[0].(*identityv1beta2.CheckInvitationStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckInvitationState indicates an expected call of CheckInvitationState. +func (mr *MockIdentityManagementAPIClientMockRecorder) CheckInvitationState(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckInvitationState", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).CheckInvitationState), varargs...) +} + +// CreateOAuth2ConsentVerifier mocks base method. +func (m *MockIdentityManagementAPIClient) CreateOAuth2ConsentVerifier(ctx context.Context, in *identityv1beta2.CreateOAuth2ConsentVerifierRequest, opts ...grpc.CallOption) (*identityv1beta2.CreateOAuth2ConsentVerifierResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateOAuth2ConsentVerifier", varargs...) + ret0, _ := ret[0].(*identityv1beta2.CreateOAuth2ConsentVerifierResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOAuth2ConsentVerifier indicates an expected call of CreateOAuth2ConsentVerifier. +func (mr *MockIdentityManagementAPIClientMockRecorder) CreateOAuth2ConsentVerifier(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOAuth2ConsentVerifier", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).CreateOAuth2ConsentVerifier), varargs...) +} + +// CreateInvitation mocks base method. +func (m *MockIdentityManagementAPIClient) CreateInvitation(ctx context.Context, in *identityv1beta2.CreateInvitationRequest, opts ...grpc.CallOption) (*identityv1beta2.CreateInvitationResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateInvitation", varargs...) + ret0, _ := ret[0].(*identityv1beta2.CreateInvitationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInvitation indicates an expected call of CreateInvitation. +func (mr *MockIdentityManagementAPIClientMockRecorder) CreateInvitation(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInvitation", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).CreateInvitation), varargs...) +} + +// DeleteDigitalTwin mocks base method. +func (m *MockIdentityManagementAPIClient) DeleteDigitalTwin(ctx context.Context, in *identityv1beta2.DeleteDigitalTwinRequest, opts ...grpc.CallOption) (*identityv1beta2.DeleteDigitalTwinResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteDigitalTwin", varargs...) + ret0, _ := ret[0].(*identityv1beta2.DeleteDigitalTwinResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDigitalTwin indicates an expected call of DeleteDigitalTwin. +func (mr *MockIdentityManagementAPIClientMockRecorder) DeleteDigitalTwin(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDigitalTwin", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).DeleteDigitalTwin), varargs...) +} + +// EnrichToken mocks base method. +func (m *MockIdentityManagementAPIClient) EnrichToken(ctx context.Context, in *identityv1beta2.EnrichTokenRequest, opts ...grpc.CallOption) (*identityv1beta2.EnrichTokenResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnrichToken", varargs...) + ret0, _ := ret[0].(*identityv1beta2.EnrichTokenResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnrichToken indicates an expected call of EnrichToken. +func (mr *MockIdentityManagementAPIClientMockRecorder) EnrichToken(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnrichToken", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).EnrichToken), varargs...) +} + +// GetAccessToken mocks base method. +func (m *MockIdentityManagementAPIClient) GetAccessToken(ctx context.Context, in *identityv1beta2.GetAccessTokenRequest, opts ...grpc.CallOption) (*identityv1beta2.GetAccessTokenResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetAccessToken", varargs...) + ret0, _ := ret[0].(*identityv1beta2.GetAccessTokenResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessToken indicates an expected call of GetAccessToken. +func (mr *MockIdentityManagementAPIClientMockRecorder) GetAccessToken(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessToken", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).GetAccessToken), varargs...) +} + +// GetDigitalTwin mocks base method. +func (m *MockIdentityManagementAPIClient) GetDigitalTwin(ctx context.Context, in *identityv1beta2.GetDigitalTwinRequest, opts ...grpc.CallOption) (*identityv1beta2.GetDigitalTwinResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDigitalTwin", varargs...) + ret0, _ := ret[0].(*identityv1beta2.GetDigitalTwinResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDigitalTwin indicates an expected call of GetDigitalTwin. +func (mr *MockIdentityManagementAPIClientMockRecorder) GetDigitalTwin(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDigitalTwin", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).GetDigitalTwin), varargs...) +} + +// GetDocument mocks base method. +func (m *MockIdentityManagementAPIClient) GetDocument(ctx context.Context, in *identityv1beta2.GetDocumentRequest, opts ...grpc.CallOption) (*identityv1beta2.GetDocumentResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetDocument", varargs...) + ret0, _ := ret[0].(*identityv1beta2.GetDocumentResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDocument indicates an expected call of GetDocument. +func (mr *MockIdentityManagementAPIClientMockRecorder) GetDocument(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocument", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).GetDocument), varargs...) +} + +// GetPasswordCredential mocks base method. +func (m *MockIdentityManagementAPIClient) GetPasswordCredential(ctx context.Context, in *identityv1beta2.GetPasswordCredentialRequest, opts ...grpc.CallOption) (*identityv1beta2.GetPasswordCredentialResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPasswordCredential", varargs...) + ret0, _ := ret[0].(*identityv1beta2.GetPasswordCredentialResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPasswordCredential indicates an expected call of GetPasswordCredential. +func (mr *MockIdentityManagementAPIClientMockRecorder) GetPasswordCredential(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordCredential", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).GetPasswordCredential), varargs...) +} + +// ImportDigitalTwins mocks base method. +func (m *MockIdentityManagementAPIClient) ImportDigitalTwins(ctx context.Context, in *identityv1beta2.ImportDigitalTwinsRequest, opts ...grpc.CallOption) (*identityv1beta2.ImportDigitalTwinsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ImportDigitalTwins", varargs...) + ret0, _ := ret[0].(*identityv1beta2.ImportDigitalTwinsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportDigitalTwins indicates an expected call of ImportDigitalTwins. +func (mr *MockIdentityManagementAPIClientMockRecorder) ImportDigitalTwins(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportDigitalTwins", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).ImportDigitalTwins), varargs...) +} + +// IsAuthorized mocks base method. +func (m *MockIdentityManagementAPIClient) IsAuthorized(ctx context.Context, in *identityv1beta2.IsAuthorizedRequest, opts ...grpc.CallOption) (*identityv1beta2.IsAuthorizedResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "IsAuthorized", varargs...) + ret0, _ := ret[0].(*identityv1beta2.IsAuthorizedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// IsAuthorized indicates an expected call of IsAuthorized. +func (mr *MockIdentityManagementAPIClientMockRecorder) IsAuthorized(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAuthorized", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).IsAuthorized), varargs...) +} + +// ListDigitalTwins mocks base method. +func (m *MockIdentityManagementAPIClient) ListDigitalTwins(ctx context.Context, in *identityv1beta2.ListDigitalTwinsRequest, opts ...grpc.CallOption) (*identityv1beta2.ListDigitalTwinsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDigitalTwins", varargs...) + ret0, _ := ret[0].(*identityv1beta2.ListDigitalTwinsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDigitalTwins indicates an expected call of ListDigitalTwins. +func (mr *MockIdentityManagementAPIClientMockRecorder) ListDigitalTwins(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDigitalTwins", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).ListDigitalTwins), varargs...) +} + +// ListDocuments mocks base method. +func (m *MockIdentityManagementAPIClient) ListDocuments(ctx context.Context, in *identityv1beta2.ListDocumentsRequest, opts ...grpc.CallOption) (*identityv1beta2.ListDocumentsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListDocuments", varargs...) + ret0, _ := ret[0].(*identityv1beta2.ListDocumentsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDocuments indicates an expected call of ListDocuments. +func (mr *MockIdentityManagementAPIClientMockRecorder) ListDocuments(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocuments", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).ListDocuments), varargs...) +} + +// MutateDocuments mocks base method. +func (m *MockIdentityManagementAPIClient) MutateDocuments(ctx context.Context, in *identityv1beta2.MutateDocumentsRequest, opts ...grpc.CallOption) (*identityv1beta2.MutateDocumentsResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MutateDocuments", varargs...) + ret0, _ := ret[0].(*identityv1beta2.MutateDocumentsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MutateDocuments indicates an expected call of MutateDocuments. +func (mr *MockIdentityManagementAPIClientMockRecorder) MutateDocuments(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MutateDocuments", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).MutateDocuments), varargs...) +} + +// PatchDigitalTwin mocks base method. +func (m *MockIdentityManagementAPIClient) PatchDigitalTwin(ctx context.Context, in *identityv1beta2.PatchDigitalTwinRequest, opts ...grpc.CallOption) (*identityv1beta2.PatchDigitalTwinResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PatchDigitalTwin", varargs...) + ret0, _ := ret[0].(*identityv1beta2.PatchDigitalTwinResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PatchDigitalTwin indicates an expected call of PatchDigitalTwin. +func (mr *MockIdentityManagementAPIClientMockRecorder) PatchDigitalTwin(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDigitalTwin", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).PatchDigitalTwin), varargs...) +} + +// RegisterDigitalTwinWithoutCredential mocks base method. +func (m *MockIdentityManagementAPIClient) RegisterDigitalTwinWithoutCredential(ctx context.Context, in *identityv1beta2.RegisterDigitalTwinWithoutCredentialRequest, opts ...grpc.CallOption) (*identityv1beta2.RegisterDigitalTwinWithoutCredentialResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RegisterDigitalTwinWithoutCredential", varargs...) + ret0, _ := ret[0].(*identityv1beta2.RegisterDigitalTwinWithoutCredentialResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterDigitalTwinWithoutCredential indicates an expected call of RegisterDigitalTwinWithoutCredential. +func (mr *MockIdentityManagementAPIClientMockRecorder) RegisterDigitalTwinWithoutCredential(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDigitalTwinWithoutCredential", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).RegisterDigitalTwinWithoutCredential), varargs...) +} + +// ResendInvitation mocks base method. +func (m *MockIdentityManagementAPIClient) ResendInvitation(ctx context.Context, in *identityv1beta2.ResendInvitationRequest, opts ...grpc.CallOption) (*identityv1beta2.ResendInvitationResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResendInvitation", varargs...) + ret0, _ := ret[0].(*identityv1beta2.ResendInvitationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResendInvitation indicates an expected call of ResendInvitation. +func (mr *MockIdentityManagementAPIClientMockRecorder) ResendInvitation(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendInvitation", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).ResendInvitation), varargs...) +} + +// RunQuery mocks base method. +func (m *MockIdentityManagementAPIClient) RunQuery(ctx context.Context, in *identityv1beta2.RunQueryRequest, opts ...grpc.CallOption) (identityv1beta2.IdentityManagementAPI_RunQueryClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RunQuery", varargs...) + ret0, _ := ret[0].(identityv1beta2.IdentityManagementAPI_RunQueryClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RunQuery indicates an expected call of RunQuery. +func (mr *MockIdentityManagementAPIClientMockRecorder) RunQuery(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunQuery", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).RunQuery), varargs...) +} + +// SelfServiceTerminateSession mocks base method. +func (m *MockIdentityManagementAPIClient) SelfServiceTerminateSession(ctx context.Context, in *identityv1beta2.SelfServiceTerminateSessionRequest, opts ...grpc.CallOption) (*identityv1beta2.SelfServiceTerminateSessionResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SelfServiceTerminateSession", varargs...) + ret0, _ := ret[0].(*identityv1beta2.SelfServiceTerminateSessionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelfServiceTerminateSession indicates an expected call of SelfServiceTerminateSession. +func (mr *MockIdentityManagementAPIClientMockRecorder) SelfServiceTerminateSession(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelfServiceTerminateSession", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).SelfServiceTerminateSession), varargs...) +} + +// SessionIntrospect mocks base method. +func (m *MockIdentityManagementAPIClient) SessionIntrospect(ctx context.Context, in *identityv1beta2.SessionIntrospectRequest, opts ...grpc.CallOption) (*identityv1beta2.SessionIntrospectResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SessionIntrospect", varargs...) + ret0, _ := ret[0].(*identityv1beta2.SessionIntrospectResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SessionIntrospect indicates an expected call of SessionIntrospect. +func (mr *MockIdentityManagementAPIClientMockRecorder) SessionIntrospect(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SessionIntrospect", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).SessionIntrospect), varargs...) +} + +// StartDigitalTwinEmailVerification mocks base method. +func (m *MockIdentityManagementAPIClient) StartDigitalTwinEmailVerification(ctx context.Context, in *identityv1beta2.StartDigitalTwinEmailVerificationRequest, opts ...grpc.CallOption) (*identityv1beta2.StartDigitalTwinEmailVerificationResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartDigitalTwinEmailVerification", varargs...) + ret0, _ := ret[0].(*identityv1beta2.StartDigitalTwinEmailVerificationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartDigitalTwinEmailVerification indicates an expected call of StartDigitalTwinEmailVerification. +func (mr *MockIdentityManagementAPIClientMockRecorder) StartDigitalTwinEmailVerification(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDigitalTwinEmailVerification", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).StartDigitalTwinEmailVerification), varargs...) +} + +// StartForgottenPasswordFlow mocks base method. +func (m *MockIdentityManagementAPIClient) StartForgottenPasswordFlow(ctx context.Context, in *identityv1beta2.StartForgottenPasswordFlowRequest, opts ...grpc.CallOption) (*identityv1beta2.StartForgottenPasswordFlowResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartForgottenPasswordFlow", varargs...) + ret0, _ := ret[0].(*identityv1beta2.StartForgottenPasswordFlowResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartForgottenPasswordFlow indicates an expected call of StartForgottenPasswordFlow. +func (mr *MockIdentityManagementAPIClientMockRecorder) StartForgottenPasswordFlow(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartForgottenPasswordFlow", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).StartForgottenPasswordFlow), varargs...) +} + +// TokenIntrospect mocks base method. +func (m *MockIdentityManagementAPIClient) TokenIntrospect(ctx context.Context, in *identityv1beta2.TokenIntrospectRequest, opts ...grpc.CallOption) (*identityv1beta2.TokenIntrospectResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TokenIntrospect", varargs...) + ret0, _ := ret[0].(*identityv1beta2.TokenIntrospectResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TokenIntrospect indicates an expected call of TokenIntrospect. +func (mr *MockIdentityManagementAPIClientMockRecorder) TokenIntrospect(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenIntrospect", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).TokenIntrospect), varargs...) +} + +// UpdatePasswordCredential mocks base method. +func (m *MockIdentityManagementAPIClient) UpdatePasswordCredential(ctx context.Context, in *identityv1beta2.UpdatePasswordCredentialRequest, opts ...grpc.CallOption) (*identityv1beta2.UpdatePasswordCredentialResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdatePasswordCredential", varargs...) + ret0, _ := ret[0].(*identityv1beta2.UpdatePasswordCredentialResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePasswordCredential indicates an expected call of UpdatePasswordCredential. +func (mr *MockIdentityManagementAPIClientMockRecorder) UpdatePasswordCredential(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePasswordCredential", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).UpdatePasswordCredential), varargs...) +} + +// VerifyDigitalTwinEmail mocks base method. +func (m *MockIdentityManagementAPIClient) VerifyDigitalTwinEmail(ctx context.Context, in *identityv1beta2.VerifyDigitalTwinEmailRequest, opts ...grpc.CallOption) (*identityv1beta2.VerifyDigitalTwinEmailResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "VerifyDigitalTwinEmail", varargs...) + ret0, _ := ret[0].(*identityv1beta2.VerifyDigitalTwinEmailResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyDigitalTwinEmail indicates an expected call of VerifyDigitalTwinEmail. +func (mr *MockIdentityManagementAPIClientMockRecorder) VerifyDigitalTwinEmail(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyDigitalTwinEmail", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).VerifyDigitalTwinEmail), varargs...) +} + +// MockIdentityManagementAPI_BatchGetDocumentsClient is a mock of IdentityManagementAPI_BatchGetDocumentsClient interface. +type MockIdentityManagementAPI_BatchGetDocumentsClient struct { + ctrl *gomock.Controller + recorder *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder +} + +// MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder is the mock recorder for MockIdentityManagementAPI_BatchGetDocumentsClient. +type MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder struct { + mock *MockIdentityManagementAPI_BatchGetDocumentsClient +} + +// NewMockIdentityManagementAPI_BatchGetDocumentsClient creates a new mock instance. +func NewMockIdentityManagementAPI_BatchGetDocumentsClient(ctrl *gomock.Controller) *MockIdentityManagementAPI_BatchGetDocumentsClient { + mock := &MockIdentityManagementAPI_BatchGetDocumentsClient{ctrl: ctrl} + mock.recorder = &MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIdentityManagementAPI_BatchGetDocumentsClient) EXPECT() *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder { + return m.recorder +} + +// CloseSend mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsClient) CloseSend() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseSend") + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseSend indicates an expected call of CloseSend. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder) CloseSend() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsClient)(nil).CloseSend)) +} + +// Context mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsClient) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsClient)(nil).Context)) +} + +// Header mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsClient) Header() (metadata.MD, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header") + ret0, _ := ret[0].(metadata.MD) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder) Header() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsClient)(nil).Header)) +} + +// Recv mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsClient) Recv() (*identityv1beta2.BatchGetDocumentsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*identityv1beta2.BatchGetDocumentsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsClient)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_BatchGetDocumentsClient) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsClient)(nil).RecvMsg), m) +} + +// SendMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_BatchGetDocumentsClient) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsClient)(nil).SendMsg), m) +} + +// Trailer mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsClient) Trailer() metadata.MD { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Trailer") + ret0, _ := ret[0].(metadata.MD) + return ret0 +} + +// Trailer indicates an expected call of Trailer. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsClientMockRecorder) Trailer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsClient)(nil).Trailer)) +} + +// MockIdentityManagementAPI_RunQueryClient is a mock of IdentityManagementAPI_RunQueryClient interface. +type MockIdentityManagementAPI_RunQueryClient struct { + ctrl *gomock.Controller + recorder *MockIdentityManagementAPI_RunQueryClientMockRecorder +} + +// MockIdentityManagementAPI_RunQueryClientMockRecorder is the mock recorder for MockIdentityManagementAPI_RunQueryClient. +type MockIdentityManagementAPI_RunQueryClientMockRecorder struct { + mock *MockIdentityManagementAPI_RunQueryClient +} + +// NewMockIdentityManagementAPI_RunQueryClient creates a new mock instance. +func NewMockIdentityManagementAPI_RunQueryClient(ctrl *gomock.Controller) *MockIdentityManagementAPI_RunQueryClient { + mock := &MockIdentityManagementAPI_RunQueryClient{ctrl: ctrl} + mock.recorder = &MockIdentityManagementAPI_RunQueryClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIdentityManagementAPI_RunQueryClient) EXPECT() *MockIdentityManagementAPI_RunQueryClientMockRecorder { + return m.recorder +} + +// CloseSend mocks base method. +func (m *MockIdentityManagementAPI_RunQueryClient) CloseSend() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CloseSend") + ret0, _ := ret[0].(error) + return ret0 +} + +// CloseSend indicates an expected call of CloseSend. +func (mr *MockIdentityManagementAPI_RunQueryClientMockRecorder) CloseSend() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryClient)(nil).CloseSend)) +} + +// Context mocks base method. +func (m *MockIdentityManagementAPI_RunQueryClient) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockIdentityManagementAPI_RunQueryClientMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryClient)(nil).Context)) +} + +// Header mocks base method. +func (m *MockIdentityManagementAPI_RunQueryClient) Header() (metadata.MD, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Header") + ret0, _ := ret[0].(metadata.MD) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Header indicates an expected call of Header. +func (mr *MockIdentityManagementAPI_RunQueryClientMockRecorder) Header() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryClient)(nil).Header)) +} + +// Recv mocks base method. +func (m *MockIdentityManagementAPI_RunQueryClient) Recv() (*identityv1beta2.RunQueryResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Recv") + ret0, _ := ret[0].(*identityv1beta2.RunQueryResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Recv indicates an expected call of Recv. +func (mr *MockIdentityManagementAPI_RunQueryClientMockRecorder) Recv() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryClient)(nil).Recv)) +} + +// RecvMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_RunQueryClient) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockIdentityManagementAPI_RunQueryClientMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryClient)(nil).RecvMsg), m) +} + +// SendMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_RunQueryClient) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockIdentityManagementAPI_RunQueryClientMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryClient)(nil).SendMsg), m) +} + +// Trailer mocks base method. +func (m *MockIdentityManagementAPI_RunQueryClient) Trailer() metadata.MD { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Trailer") + ret0, _ := ret[0].(metadata.MD) + return ret0 +} + +// Trailer indicates an expected call of Trailer. +func (mr *MockIdentityManagementAPI_RunQueryClientMockRecorder) Trailer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryClient)(nil).Trailer)) +} + +// MockIdentityManagementAPIServer is a mock of IdentityManagementAPIServer interface. +type MockIdentityManagementAPIServer struct { + ctrl *gomock.Controller + recorder *MockIdentityManagementAPIServerMockRecorder +} + +// MockIdentityManagementAPIServerMockRecorder is the mock recorder for MockIdentityManagementAPIServer. +type MockIdentityManagementAPIServerMockRecorder struct { + mock *MockIdentityManagementAPIServer +} + +// NewMockIdentityManagementAPIServer creates a new mock instance. +func NewMockIdentityManagementAPIServer(ctrl *gomock.Controller) *MockIdentityManagementAPIServer { + mock := &MockIdentityManagementAPIServer{ctrl: ctrl} + mock.recorder = &MockIdentityManagementAPIServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIdentityManagementAPIServer) EXPECT() *MockIdentityManagementAPIServerMockRecorder { + return m.recorder +} + +// BatchGetDocuments mocks base method. +func (m *MockIdentityManagementAPIServer) BatchGetDocuments(arg0 *identityv1beta2.BatchGetDocumentsRequest, arg1 identityv1beta2.IdentityManagementAPI_BatchGetDocumentsServer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchGetDocuments", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// BatchGetDocuments indicates an expected call of BatchGetDocuments. +func (mr *MockIdentityManagementAPIServerMockRecorder) BatchGetDocuments(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchGetDocuments", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).BatchGetDocuments), arg0, arg1) +} + +// CancelInvitation mocks base method. +func (m *MockIdentityManagementAPIServer) CancelInvitation(arg0 context.Context, arg1 *identityv1beta2.CancelInvitationRequest) (*identityv1beta2.CancelInvitationResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelInvitation", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.CancelInvitationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelInvitation indicates an expected call of CancelInvitation. +func (mr *MockIdentityManagementAPIServerMockRecorder) CancelInvitation(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInvitation", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).CancelInvitation), arg0, arg1) +} + +// ChangePassword mocks base method. +func (m *MockIdentityManagementAPIServer) ChangePassword(arg0 context.Context, arg1 *identityv1beta2.ChangePasswordRequest) (*identityv1beta2.ChangePasswordResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ChangePassword", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.ChangePasswordResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ChangePassword indicates an expected call of ChangePassword. +func (mr *MockIdentityManagementAPIServerMockRecorder) ChangePassword(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePassword", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).ChangePassword), arg0, arg1) +} + +// CheckOAuth2ConsentChallenge mocks base method. +func (m *MockIdentityManagementAPIServer) CheckOAuth2ConsentChallenge(arg0 context.Context, arg1 *identityv1beta2.CheckOAuth2ConsentChallengeRequest) (*identityv1beta2.CheckOAuth2ConsentChallengeResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckOAuth2ConsentChallenge", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.CheckOAuth2ConsentChallengeResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckOAuth2ConsentChallenge indicates an expected call of CheckOAuth2ConsentChallenge. +func (mr *MockIdentityManagementAPIServerMockRecorder) CheckOAuth2ConsentChallenge(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckOAuth2ConsentChallenge", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).CheckOAuth2ConsentChallenge), arg0, arg1) +} + +// CheckInvitationState mocks base method. +func (m *MockIdentityManagementAPIServer) CheckInvitationState(arg0 context.Context, arg1 *identityv1beta2.CheckInvitationStateRequest) (*identityv1beta2.CheckInvitationStateResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckInvitationState", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.CheckInvitationStateResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CheckInvitationState indicates an expected call of CheckInvitationState. +func (mr *MockIdentityManagementAPIServerMockRecorder) CheckInvitationState(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckInvitationState", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).CheckInvitationState), arg0, arg1) +} + +// CreateConsentVerifier mocks base method. +func (m *MockIdentityManagementAPIServer) CreateConsentVerifier(arg0 context.Context, arg1 *identityv1beta2.CreateOAuth2ConsentVerifierRequest) (*identityv1beta2.CreateOAuth2ConsentVerifierResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateConsentVerifier", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.CreateOAuth2ConsentVerifierResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateConsentVerifier indicates an expected call of CreateConsentVerifier. +func (mr *MockIdentityManagementAPIServerMockRecorder) CreateConsentVerifier(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConsentVerifier", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).CreateConsentVerifier), arg0, arg1) +} + +// CreateInvitation mocks base method. +func (m *MockIdentityManagementAPIServer) CreateInvitation(arg0 context.Context, arg1 *identityv1beta2.CreateInvitationRequest) (*identityv1beta2.CreateInvitationResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateInvitation", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.CreateInvitationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateInvitation indicates an expected call of CreateInvitation. +func (mr *MockIdentityManagementAPIServerMockRecorder) CreateInvitation(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInvitation", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).CreateInvitation), arg0, arg1) +} + +// DeleteDigitalTwin mocks base method. +func (m *MockIdentityManagementAPIServer) DeleteDigitalTwin(arg0 context.Context, arg1 *identityv1beta2.DeleteDigitalTwinRequest) (*identityv1beta2.DeleteDigitalTwinResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteDigitalTwin", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.DeleteDigitalTwinResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteDigitalTwin indicates an expected call of DeleteDigitalTwin. +func (mr *MockIdentityManagementAPIServerMockRecorder) DeleteDigitalTwin(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDigitalTwin", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).DeleteDigitalTwin), arg0, arg1) +} + +// EnrichToken mocks base method. +func (m *MockIdentityManagementAPIServer) EnrichToken(arg0 context.Context, arg1 *identityv1beta2.EnrichTokenRequest) (*identityv1beta2.EnrichTokenResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnrichToken", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.EnrichTokenResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnrichToken indicates an expected call of EnrichToken. +func (mr *MockIdentityManagementAPIServerMockRecorder) EnrichToken(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnrichToken", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).EnrichToken), arg0, arg1) +} + +// GetAccessToken mocks base method. +func (m *MockIdentityManagementAPIServer) GetAccessToken(arg0 context.Context, arg1 *identityv1beta2.GetAccessTokenRequest) (*identityv1beta2.GetAccessTokenResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAccessToken", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.GetAccessTokenResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAccessToken indicates an expected call of GetAccessToken. +func (mr *MockIdentityManagementAPIServerMockRecorder) GetAccessToken(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessToken", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).GetAccessToken), arg0, arg1) +} + +// GetDigitalTwin mocks base method. +func (m *MockIdentityManagementAPIServer) GetDigitalTwin(arg0 context.Context, arg1 *identityv1beta2.GetDigitalTwinRequest) (*identityv1beta2.GetDigitalTwinResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDigitalTwin", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.GetDigitalTwinResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDigitalTwin indicates an expected call of GetDigitalTwin. +func (mr *MockIdentityManagementAPIServerMockRecorder) GetDigitalTwin(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDigitalTwin", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).GetDigitalTwin), arg0, arg1) +} + +// GetDocument mocks base method. +func (m *MockIdentityManagementAPIServer) GetDocument(arg0 context.Context, arg1 *identityv1beta2.GetDocumentRequest) (*identityv1beta2.GetDocumentResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDocument", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.GetDocumentResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDocument indicates an expected call of GetDocument. +func (mr *MockIdentityManagementAPIServerMockRecorder) GetDocument(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocument", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).GetDocument), arg0, arg1) +} + +// GetPasswordCredential mocks base method. +func (m *MockIdentityManagementAPIServer) GetPasswordCredential(arg0 context.Context, arg1 *identityv1beta2.GetPasswordCredentialRequest) (*identityv1beta2.GetPasswordCredentialResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPasswordCredential", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.GetPasswordCredentialResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPasswordCredential indicates an expected call of GetPasswordCredential. +func (mr *MockIdentityManagementAPIServerMockRecorder) GetPasswordCredential(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordCredential", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).GetPasswordCredential), arg0, arg1) +} + +// ImportDigitalTwins mocks base method. +func (m *MockIdentityManagementAPIServer) ImportDigitalTwins(arg0 context.Context, arg1 *identityv1beta2.ImportDigitalTwinsRequest) (*identityv1beta2.ImportDigitalTwinsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ImportDigitalTwins", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.ImportDigitalTwinsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ImportDigitalTwins indicates an expected call of ImportDigitalTwins. +func (mr *MockIdentityManagementAPIServerMockRecorder) ImportDigitalTwins(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportDigitalTwins", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).ImportDigitalTwins), arg0, arg1) +} + +// IsAuthorized mocks base method. +func (m *MockIdentityManagementAPIServer) IsAuthorized(arg0 context.Context, arg1 *identityv1beta2.IsAuthorizedRequest) (*identityv1beta2.IsAuthorizedResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsAuthorized", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.IsAuthorizedResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// IsAuthorized indicates an expected call of IsAuthorized. +func (mr *MockIdentityManagementAPIServerMockRecorder) IsAuthorized(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAuthorized", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).IsAuthorized), arg0, arg1) +} + +// ListDigitalTwins mocks base method. +func (m *MockIdentityManagementAPIServer) ListDigitalTwins(arg0 context.Context, arg1 *identityv1beta2.ListDigitalTwinsRequest) (*identityv1beta2.ListDigitalTwinsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDigitalTwins", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.ListDigitalTwinsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDigitalTwins indicates an expected call of ListDigitalTwins. +func (mr *MockIdentityManagementAPIServerMockRecorder) ListDigitalTwins(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDigitalTwins", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).ListDigitalTwins), arg0, arg1) +} + +// ListDocuments mocks base method. +func (m *MockIdentityManagementAPIServer) ListDocuments(arg0 context.Context, arg1 *identityv1beta2.ListDocumentsRequest) (*identityv1beta2.ListDocumentsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListDocuments", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.ListDocumentsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListDocuments indicates an expected call of ListDocuments. +func (mr *MockIdentityManagementAPIServerMockRecorder) ListDocuments(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocuments", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).ListDocuments), arg0, arg1) +} + +// MutateDocuments mocks base method. +func (m *MockIdentityManagementAPIServer) MutateDocuments(arg0 context.Context, arg1 *identityv1beta2.MutateDocumentsRequest) (*identityv1beta2.MutateDocumentsResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "MutateDocuments", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.MutateDocumentsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// MutateDocuments indicates an expected call of MutateDocuments. +func (mr *MockIdentityManagementAPIServerMockRecorder) MutateDocuments(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MutateDocuments", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).MutateDocuments), arg0, arg1) +} + +// PatchDigitalTwin mocks base method. +func (m *MockIdentityManagementAPIServer) PatchDigitalTwin(arg0 context.Context, arg1 *identityv1beta2.PatchDigitalTwinRequest) (*identityv1beta2.PatchDigitalTwinResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PatchDigitalTwin", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.PatchDigitalTwinResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PatchDigitalTwin indicates an expected call of PatchDigitalTwin. +func (mr *MockIdentityManagementAPIServerMockRecorder) PatchDigitalTwin(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDigitalTwin", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).PatchDigitalTwin), arg0, arg1) +} + +// RegisterDigitalTwinWithoutCredential mocks base method. +func (m *MockIdentityManagementAPIServer) RegisterDigitalTwinWithoutCredential(arg0 context.Context, arg1 *identityv1beta2.RegisterDigitalTwinWithoutCredentialRequest) (*identityv1beta2.RegisterDigitalTwinWithoutCredentialResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RegisterDigitalTwinWithoutCredential", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.RegisterDigitalTwinWithoutCredentialResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RegisterDigitalTwinWithoutCredential indicates an expected call of RegisterDigitalTwinWithoutCredential. +func (mr *MockIdentityManagementAPIServerMockRecorder) RegisterDigitalTwinWithoutCredential(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterDigitalTwinWithoutCredential", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).RegisterDigitalTwinWithoutCredential), arg0, arg1) +} + +// ResendInvitation mocks base method. +func (m *MockIdentityManagementAPIServer) ResendInvitation(arg0 context.Context, arg1 *identityv1beta2.ResendInvitationRequest) (*identityv1beta2.ResendInvitationResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResendInvitation", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.ResendInvitationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResendInvitation indicates an expected call of ResendInvitation. +func (mr *MockIdentityManagementAPIServerMockRecorder) ResendInvitation(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendInvitation", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).ResendInvitation), arg0, arg1) +} + +// RunQuery mocks base method. +func (m *MockIdentityManagementAPIServer) RunQuery(arg0 *identityv1beta2.RunQueryRequest, arg1 identityv1beta2.IdentityManagementAPI_RunQueryServer) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RunQuery", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// RunQuery indicates an expected call of RunQuery. +func (mr *MockIdentityManagementAPIServerMockRecorder) RunQuery(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunQuery", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).RunQuery), arg0, arg1) +} + +// SelfServiceTerminateSession mocks base method. +func (m *MockIdentityManagementAPIServer) SelfServiceTerminateSession(arg0 context.Context, arg1 *identityv1beta2.SelfServiceTerminateSessionRequest) (*identityv1beta2.SelfServiceTerminateSessionResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SelfServiceTerminateSession", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.SelfServiceTerminateSessionResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SelfServiceTerminateSession indicates an expected call of SelfServiceTerminateSession. +func (mr *MockIdentityManagementAPIServerMockRecorder) SelfServiceTerminateSession(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelfServiceTerminateSession", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).SelfServiceTerminateSession), arg0, arg1) +} + +// SessionIntrospect mocks base method. +func (m *MockIdentityManagementAPIServer) SessionIntrospect(arg0 context.Context, arg1 *identityv1beta2.SessionIntrospectRequest) (*identityv1beta2.SessionIntrospectResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SessionIntrospect", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.SessionIntrospectResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SessionIntrospect indicates an expected call of SessionIntrospect. +func (mr *MockIdentityManagementAPIServerMockRecorder) SessionIntrospect(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SessionIntrospect", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).SessionIntrospect), arg0, arg1) +} + +// StartDigitalTwinEmailVerification mocks base method. +func (m *MockIdentityManagementAPIServer) StartDigitalTwinEmailVerification(arg0 context.Context, arg1 *identityv1beta2.StartDigitalTwinEmailVerificationRequest) (*identityv1beta2.StartDigitalTwinEmailVerificationResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartDigitalTwinEmailVerification", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.StartDigitalTwinEmailVerificationResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartDigitalTwinEmailVerification indicates an expected call of StartDigitalTwinEmailVerification. +func (mr *MockIdentityManagementAPIServerMockRecorder) StartDigitalTwinEmailVerification(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartDigitalTwinEmailVerification", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).StartDigitalTwinEmailVerification), arg0, arg1) +} + +// StartForgottenPasswordFlow mocks base method. +func (m *MockIdentityManagementAPIServer) StartForgottenPasswordFlow(arg0 context.Context, arg1 *identityv1beta2.StartForgottenPasswordFlowRequest) (*identityv1beta2.StartForgottenPasswordFlowResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartForgottenPasswordFlow", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.StartForgottenPasswordFlowResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartForgottenPasswordFlow indicates an expected call of StartForgottenPasswordFlow. +func (mr *MockIdentityManagementAPIServerMockRecorder) StartForgottenPasswordFlow(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartForgottenPasswordFlow", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).StartForgottenPasswordFlow), arg0, arg1) +} + +// TokenIntrospect mocks base method. +func (m *MockIdentityManagementAPIServer) TokenIntrospect(arg0 context.Context, arg1 *identityv1beta2.TokenIntrospectRequest) (*identityv1beta2.TokenIntrospectResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TokenIntrospect", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.TokenIntrospectResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TokenIntrospect indicates an expected call of TokenIntrospect. +func (mr *MockIdentityManagementAPIServerMockRecorder) TokenIntrospect(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TokenIntrospect", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).TokenIntrospect), arg0, arg1) +} + +// UpdatePasswordCredential mocks base method. +func (m *MockIdentityManagementAPIServer) UpdatePasswordCredential(arg0 context.Context, arg1 *identityv1beta2.UpdatePasswordCredentialRequest) (*identityv1beta2.UpdatePasswordCredentialResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePasswordCredential", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.UpdatePasswordCredentialResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePasswordCredential indicates an expected call of UpdatePasswordCredential. +func (mr *MockIdentityManagementAPIServerMockRecorder) UpdatePasswordCredential(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePasswordCredential", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).UpdatePasswordCredential), arg0, arg1) +} + +// VerifyDigitalTwinEmail mocks base method. +func (m *MockIdentityManagementAPIServer) VerifyDigitalTwinEmail(arg0 context.Context, arg1 *identityv1beta2.VerifyDigitalTwinEmailRequest) (*identityv1beta2.VerifyDigitalTwinEmailResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VerifyDigitalTwinEmail", arg0, arg1) + ret0, _ := ret[0].(*identityv1beta2.VerifyDigitalTwinEmailResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyDigitalTwinEmail indicates an expected call of VerifyDigitalTwinEmail. +func (mr *MockIdentityManagementAPIServerMockRecorder) VerifyDigitalTwinEmail(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyDigitalTwinEmail", reflect.TypeOf((*MockIdentityManagementAPIServer)(nil).VerifyDigitalTwinEmail), arg0, arg1) +} + +// MockUnsafeIdentityManagementAPIServer is a mock of UnsafeIdentityManagementAPIServer interface. +type MockUnsafeIdentityManagementAPIServer struct { + ctrl *gomock.Controller + recorder *MockUnsafeIdentityManagementAPIServerMockRecorder +} + +// MockUnsafeIdentityManagementAPIServerMockRecorder is the mock recorder for MockUnsafeIdentityManagementAPIServer. +type MockUnsafeIdentityManagementAPIServerMockRecorder struct { + mock *MockUnsafeIdentityManagementAPIServer +} + +// NewMockUnsafeIdentityManagementAPIServer creates a new mock instance. +func NewMockUnsafeIdentityManagementAPIServer(ctrl *gomock.Controller) *MockUnsafeIdentityManagementAPIServer { + mock := &MockUnsafeIdentityManagementAPIServer{ctrl: ctrl} + mock.recorder = &MockUnsafeIdentityManagementAPIServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockUnsafeIdentityManagementAPIServer) EXPECT() *MockUnsafeIdentityManagementAPIServerMockRecorder { + return m.recorder +} + +// mustEmbedUnimplementedIdentityManagementAPIServer mocks base method. +func (m *MockUnsafeIdentityManagementAPIServer) mustEmbedUnimplementedIdentityManagementAPIServer() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "mustEmbedUnimplementedIdentityManagementAPIServer") +} + +// mustEmbedUnimplementedIdentityManagementAPIServer indicates an expected call of mustEmbedUnimplementedIdentityManagementAPIServer. +func (mr *MockUnsafeIdentityManagementAPIServerMockRecorder) mustEmbedUnimplementedIdentityManagementAPIServer() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "mustEmbedUnimplementedIdentityManagementAPIServer", reflect.TypeOf((*MockUnsafeIdentityManagementAPIServer)(nil).mustEmbedUnimplementedIdentityManagementAPIServer)) +} + +// MockIdentityManagementAPI_BatchGetDocumentsServer is a mock of IdentityManagementAPI_BatchGetDocumentsServer interface. +type MockIdentityManagementAPI_BatchGetDocumentsServer struct { + ctrl *gomock.Controller + recorder *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder +} + +// MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder is the mock recorder for MockIdentityManagementAPI_BatchGetDocumentsServer. +type MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder struct { + mock *MockIdentityManagementAPI_BatchGetDocumentsServer +} + +// NewMockIdentityManagementAPI_BatchGetDocumentsServer creates a new mock instance. +func NewMockIdentityManagementAPI_BatchGetDocumentsServer(ctrl *gomock.Controller) *MockIdentityManagementAPI_BatchGetDocumentsServer { + mock := &MockIdentityManagementAPI_BatchGetDocumentsServer{ctrl: ctrl} + mock.recorder = &MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIdentityManagementAPI_BatchGetDocumentsServer) EXPECT() *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsServer) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsServer)(nil).Context)) +} + +// RecvMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_BatchGetDocumentsServer) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsServer)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsServer) Send(arg0 *identityv1beta2.BatchGetDocumentsResponse) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsServer)(nil).Send), arg0) +} + +// SendHeader mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsServer) SendHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendHeader indicates an expected call of SendHeader. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsServer)(nil).SendHeader), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_BatchGetDocumentsServer) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsServer)(nil).SendMsg), m) +} + +// SetHeader mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsServer) SetHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetHeader indicates an expected call of SetHeader. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsServer)(nil).SetHeader), arg0) +} + +// SetTrailer mocks base method. +func (m *MockIdentityManagementAPI_BatchGetDocumentsServer) SetTrailer(arg0 metadata.MD) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTrailer", arg0) +} + +// SetTrailer indicates an expected call of SetTrailer. +func (mr *MockIdentityManagementAPI_BatchGetDocumentsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockIdentityManagementAPI_BatchGetDocumentsServer)(nil).SetTrailer), arg0) +} + +// MockIdentityManagementAPI_RunQueryServer is a mock of IdentityManagementAPI_RunQueryServer interface. +type MockIdentityManagementAPI_RunQueryServer struct { + ctrl *gomock.Controller + recorder *MockIdentityManagementAPI_RunQueryServerMockRecorder +} + +// MockIdentityManagementAPI_RunQueryServerMockRecorder is the mock recorder for MockIdentityManagementAPI_RunQueryServer. +type MockIdentityManagementAPI_RunQueryServerMockRecorder struct { + mock *MockIdentityManagementAPI_RunQueryServer +} + +// NewMockIdentityManagementAPI_RunQueryServer creates a new mock instance. +func NewMockIdentityManagementAPI_RunQueryServer(ctrl *gomock.Controller) *MockIdentityManagementAPI_RunQueryServer { + mock := &MockIdentityManagementAPI_RunQueryServer{ctrl: ctrl} + mock.recorder = &MockIdentityManagementAPI_RunQueryServerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockIdentityManagementAPI_RunQueryServer) EXPECT() *MockIdentityManagementAPI_RunQueryServerMockRecorder { + return m.recorder +} + +// Context mocks base method. +func (m *MockIdentityManagementAPI_RunQueryServer) Context() context.Context { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Context") + ret0, _ := ret[0].(context.Context) + return ret0 +} + +// Context indicates an expected call of Context. +func (mr *MockIdentityManagementAPI_RunQueryServerMockRecorder) Context() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryServer)(nil).Context)) +} + +// RecvMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_RunQueryServer) RecvMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "RecvMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// RecvMsg indicates an expected call of RecvMsg. +func (mr *MockIdentityManagementAPI_RunQueryServerMockRecorder) RecvMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryServer)(nil).RecvMsg), m) +} + +// Send mocks base method. +func (m *MockIdentityManagementAPI_RunQueryServer) Send(arg0 *identityv1beta2.RunQueryResponse) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Send", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Send indicates an expected call of Send. +func (mr *MockIdentityManagementAPI_RunQueryServerMockRecorder) Send(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryServer)(nil).Send), arg0) +} + +// SendHeader mocks base method. +func (m *MockIdentityManagementAPI_RunQueryServer) SendHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SendHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendHeader indicates an expected call of SendHeader. +func (mr *MockIdentityManagementAPI_RunQueryServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryServer)(nil).SendHeader), arg0) +} + +// SendMsg mocks base method. +func (m_2 *MockIdentityManagementAPI_RunQueryServer) SendMsg(m interface{}) error { + m_2.ctrl.T.Helper() + ret := m_2.ctrl.Call(m_2, "SendMsg", m) + ret0, _ := ret[0].(error) + return ret0 +} + +// SendMsg indicates an expected call of SendMsg. +func (mr *MockIdentityManagementAPI_RunQueryServerMockRecorder) SendMsg(m interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryServer)(nil).SendMsg), m) +} + +// SetHeader mocks base method. +func (m *MockIdentityManagementAPI_RunQueryServer) SetHeader(arg0 metadata.MD) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHeader", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetHeader indicates an expected call of SetHeader. +func (mr *MockIdentityManagementAPI_RunQueryServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryServer)(nil).SetHeader), arg0) +} + +// SetTrailer mocks base method. +func (m *MockIdentityManagementAPI_RunQueryServer) SetTrailer(arg0 metadata.MD) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetTrailer", arg0) +} + +// SetTrailer indicates an expected call of SetTrailer. +func (mr *MockIdentityManagementAPI_RunQueryServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockIdentityManagementAPI_RunQueryServer)(nil).SetTrailer), arg0) +} + +// CreateConsent indicates an expected call of CreateConsent. +func (mr *MockIdentityManagementAPIClientMockRecorder) CreateConsent(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateConsent", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).CreateConsent), varargs...) +} + +// CreateConsent mocks base method. +func (m *MockIdentityManagementAPIClient) CreateConsent(ctx context.Context, in *identityv1beta2.CreateConsentRequest, opts ...grpc.CallOption) (*identityv1beta2.CreateConsentResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateConsent", varargs...) + ret0, _ := ret[0].(*identityv1beta2.CreateConsentResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RevokeConsent indicates an expected call of RevokeConsent. +func (mr *MockIdentityManagementAPIClientMockRecorder) RevokeConsent(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeConsent", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).RevokeConsent), varargs...) +} + +// RevokeConsent mocks base method. +func (m *MockIdentityManagementAPIClient) RevokeConsent(ctx context.Context, in *identityv1beta2.RevokeConsentRequest, opts ...grpc.CallOption) (*identityv1beta2.RevokeConsentResponse, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RevokeConsent", varargs...) + ret0, _ := ret[0].(*identityv1beta2.RevokeConsentResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListConsents indicates an expected call of ListConsents. +func (mr *MockIdentityManagementAPIClientMockRecorder) ListConsents(ctx, in interface{}, opts ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{ctx, in}, opts...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConsents", reflect.TypeOf((*MockIdentityManagementAPIClient)(nil).ListConsents), varargs...) +} + +// ListConsents mocks base method. +func (m *MockIdentityManagementAPIClient) ListConsents(ctx context.Context, in *identityv1beta2.ListConsentsRequest, opts ...grpc.CallOption) (identityv1beta2.IdentityManagementAPI_ListConsentsClient, error) { + m.ctrl.T.Helper() + varargs := []interface{}{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListConsents", varargs...) + ret0, _ := ret[0].(identityv1beta2.IdentityManagementAPI_ListConsentsClient) + ret1, _ := ret[1].(error) + return ret0, ret1 +}