// This file was autogenerated by go-to-protobuf. Do not edit it manually!

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.9
// 	protoc        (unknown)
// source: agntcy/identity/service/v1alpha1/badge.proto

package identity_service_sdk_go

import (
	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"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// The content of the Credential.
// Multiple content types can be supported: AgentBadge, etc.
type BadgeType int32

const (
	// Unspecified Content Type.
	BadgeType_BADGE_TYPE_UNSPECIFIED BadgeType = 0
	// AgentBadge Content Type.
	// The Agent content representation following a defined schema
	// OASF: https://schema.oasf.agntcy.org/schema/objects/agent
	// Google A2A: https://github.com/google/A2A/blob/main/specification/json/a2a.json
	BadgeType_BADGE_TYPE_AGENT_BADGE BadgeType = 1
	// McpBadge Content Type.
	// The MCP content representation following a defined schema
	// The schema is defined in the MCP specification as the MCPServer type
	BadgeType_BADGE_TYPE_MCP_BADGE BadgeType = 2
)

// Enum value maps for BadgeType.
var (
	BadgeType_name = map[int32]string{
		0: "BADGE_TYPE_UNSPECIFIED",
		1: "BADGE_TYPE_AGENT_BADGE",
		2: "BADGE_TYPE_MCP_BADGE",
	}
	BadgeType_value = map[string]int32{
		"BADGE_TYPE_UNSPECIFIED": 0,
		"BADGE_TYPE_AGENT_BADGE": 1,
		"BADGE_TYPE_MCP_BADGE":   2,
	}
)

func (x BadgeType) Enum() *BadgeType {
	p := new(BadgeType)
	*p = x
	return p
}

func (x BadgeType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (BadgeType) Descriptor() protoreflect.EnumDescriptor {
	return file_agntcy_identity_service_v1alpha1_badge_proto_enumTypes[0].Descriptor()
}

func (BadgeType) Type() protoreflect.EnumType {
	return &file_agntcy_identity_service_v1alpha1_badge_proto_enumTypes[0]
}

func (x BadgeType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use BadgeType.Descriptor instead.
func (BadgeType) EnumDescriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{0}
}

// The purpose of the status entry
type CredentialStatusPurpose int32

const (
	// Unspecified status purpose
	CredentialStatusPurpose_CREDENTIAL_STATUS_PURPOSE_UNSPECIFIED CredentialStatusPurpose = 0
	// Used to cancel the validity of a verifiable credential.
	// This status is not reversible.
	CredentialStatusPurpose_CREDENTIAL_STATUS_PURPOSE_REVOCATION CredentialStatusPurpose = 1
)

// Enum value maps for CredentialStatusPurpose.
var (
	CredentialStatusPurpose_name = map[int32]string{
		0: "CREDENTIAL_STATUS_PURPOSE_UNSPECIFIED",
		1: "CREDENTIAL_STATUS_PURPOSE_REVOCATION",
	}
	CredentialStatusPurpose_value = map[string]int32{
		"CREDENTIAL_STATUS_PURPOSE_UNSPECIFIED": 0,
		"CREDENTIAL_STATUS_PURPOSE_REVOCATION":  1,
	}
)

func (x CredentialStatusPurpose) Enum() *CredentialStatusPurpose {
	p := new(CredentialStatusPurpose)
	*p = x
	return p
}

func (x CredentialStatusPurpose) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (CredentialStatusPurpose) Descriptor() protoreflect.EnumDescriptor {
	return file_agntcy_identity_service_v1alpha1_badge_proto_enumTypes[1].Descriptor()
}

func (CredentialStatusPurpose) Type() protoreflect.EnumType {
	return &file_agntcy_identity_service_v1alpha1_badge_proto_enumTypes[1]
}

func (x CredentialStatusPurpose) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use CredentialStatusPurpose.Descriptor instead.
func (CredentialStatusPurpose) EnumDescriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{1}
}

type Badge struct {
	state                protoimpl.MessageState `protogen:"open.v1"`
	VerifiableCredential *VerifiableCredential  `protobuf:"bytes,1,opt,name=verifiable_credential,json=verifiableCredential,proto3,oneof" json:"verifiable_credential,omitempty"`
	AppId                *string                `protobuf:"bytes,2,opt,name=app_id,json=appId,proto3,oneof" json:"app_id,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *Badge) Reset() {
	*x = Badge{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Badge) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Badge) ProtoMessage() {}

func (x *Badge) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Badge.ProtoReflect.Descriptor instead.
func (*Badge) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{0}
}

func (x *Badge) GetVerifiableCredential() *VerifiableCredential {
	if x != nil {
		return x.VerifiableCredential
	}
	return nil
}

func (x *Badge) GetAppId() string {
	if x != nil && x.AppId != nil {
		return *x.AppId
	}
	return ""
}

// BadgeClaims represents the content of a Badge VC defined [here]
//
// [here]: https://spec.identity.agntcy.org/docs/vc/intro/
type BadgeClaims struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The ID as defined [here]
	//
	// [here]: https://www.w3.org/TR/vc-data-model/#credential-subject
	Id *string `protobuf:"bytes,1,opt,name=id,proto3,oneof" json:"id,omitempty"`
	// The content of the badge
	Badge         *string `protobuf:"bytes,2,opt,name=badge,proto3,oneof" json:"badge,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *BadgeClaims) Reset() {
	*x = BadgeClaims{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *BadgeClaims) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*BadgeClaims) ProtoMessage() {}

func (x *BadgeClaims) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use BadgeClaims.ProtoReflect.Descriptor instead.
func (*BadgeClaims) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{1}
}

func (x *BadgeClaims) GetId() string {
	if x != nil && x.Id != nil {
		return *x.Id
	}
	return ""
}

func (x *BadgeClaims) GetBadge() string {
	if x != nil && x.Badge != nil {
		return *x.Badge
	}
	return ""
}

// CredentialSchema represents the credentialSchema property of a Verifiable Credential.
// more information can be found [here]
//
// [here]: https://www.w3.org/TR/vc-data-model-2.0/#data-schemas
type CredentialSchema struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Type specifies the type of the file
	Type *string `protobuf:"bytes,1,opt,name=type,proto3,oneof" json:"type,omitempty"`
	// The URL identifying the schema file
	Id            *string `protobuf:"bytes,2,opt,name=id,proto3,oneof" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CredentialSchema) Reset() {
	*x = CredentialSchema{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CredentialSchema) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CredentialSchema) ProtoMessage() {}

func (x *CredentialSchema) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CredentialSchema.ProtoReflect.Descriptor instead.
func (*CredentialSchema) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{2}
}

func (x *CredentialSchema) GetType() string {
	if x != nil && x.Type != nil {
		return *x.Type
	}
	return ""
}

func (x *CredentialSchema) GetId() string {
	if x != nil && x.Id != nil {
		return *x.Id
	}
	return ""
}

// CredentialStatus represents the credentialStatus property of a Verifiable Credential.
// more information can be found [here]
//
// [here]: https://www.w3.org/TR/vc-data-model-2.0/#status
type CredentialStatus struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The URL identifying the schema file
	Id *string `protobuf:"bytes,1,opt,name=id,proto3,oneof" json:"id,omitempty"`
	// Type specifies the type of the file
	Type *string `protobuf:"bytes,2,opt,name=type,proto3,oneof" json:"type,omitempty"`
	// The creation date and time of the status
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3,oneof" json:"created_at,omitempty"`
	// The value of the purpose for the status entry
	Purpose       *CredentialStatusPurpose `protobuf:"varint,4,opt,name=purpose,proto3,enum=agntcy.identity.service.v1alpha1.CredentialStatusPurpose,oneof" json:"purpose,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *CredentialStatus) Reset() {
	*x = CredentialStatus{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *CredentialStatus) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*CredentialStatus) ProtoMessage() {}

func (x *CredentialStatus) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use CredentialStatus.ProtoReflect.Descriptor instead.
func (*CredentialStatus) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{3}
}

func (x *CredentialStatus) GetId() string {
	if x != nil && x.Id != nil {
		return *x.Id
	}
	return ""
}

func (x *CredentialStatus) GetType() string {
	if x != nil && x.Type != nil {
		return *x.Type
	}
	return ""
}

func (x *CredentialStatus) GetCreatedAt() *timestamppb.Timestamp {
	if x != nil {
		return x.CreatedAt
	}
	return nil
}

func (x *CredentialStatus) GetPurpose() CredentialStatusPurpose {
	if x != nil && x.Purpose != nil {
		return *x.Purpose
	}
	return CredentialStatusPurpose_CREDENTIAL_STATUS_PURPOSE_UNSPECIFIED
}

type ErrorInfo struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Reason        *string                `protobuf:"bytes,1,opt,name=reason,proto3,oneof" json:"reason,omitempty"`
	Message       *string                `protobuf:"bytes,2,opt,name=message,proto3,oneof" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ErrorInfo) Reset() {
	*x = ErrorInfo{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ErrorInfo) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ErrorInfo) ProtoMessage() {}

func (x *ErrorInfo) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use ErrorInfo.ProtoReflect.Descriptor instead.
func (*ErrorInfo) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{4}
}

func (x *ErrorInfo) GetReason() string {
	if x != nil && x.Reason != nil {
		return *x.Reason
	}
	return ""
}

func (x *ErrorInfo) GetMessage() string {
	if x != nil && x.Message != nil {
		return *x.Message
	}
	return ""
}

// A data integrity proof provides information about the proof mechanism,
// parameters required to verify that proof, and the proof value itself.
type Proof struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of the proof
	Type *string `protobuf:"bytes,1,opt,name=type,proto3,oneof" json:"type,omitempty"`
	// The proof purpose
	ProofPurpose *string `protobuf:"bytes,2,opt,name=proof_purpose,json=proofPurpose,proto3,oneof" json:"proof_purpose,omitempty"`
	// The proof value
	ProofValue    *string `protobuf:"bytes,3,opt,name=proof_value,json=proofValue,proto3,oneof" json:"proof_value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Proof) Reset() {
	*x = Proof{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *Proof) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*Proof) ProtoMessage() {}

func (x *Proof) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Proof.ProtoReflect.Descriptor instead.
func (*Proof) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{5}
}

func (x *Proof) GetType() string {
	if x != nil && x.Type != nil {
		return *x.Type
	}
	return ""
}

func (x *Proof) GetProofPurpose() string {
	if x != nil && x.ProofPurpose != nil {
		return *x.ProofPurpose
	}
	return ""
}

func (x *Proof) GetProofValue() string {
	if x != nil && x.ProofValue != nil {
		return *x.ProofValue
	}
	return ""
}

// DataModel represents the W3C Verifiable Credential Data Model defined [here]
//
// [here]: https://www.w3.org/TR/vc-data-model/
type VerifiableCredential struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// https://www.w3.org/TR/vc-data-model/#contexts
	Context []string `protobuf:"bytes,1,rep,name=context,proto3" json:"context,omitempty"`
	// https://www.w3.org/TR/vc-data-model/#dfn-type
	Type []string `protobuf:"bytes,2,rep,name=type,proto3" json:"type,omitempty"`
	// https://www.w3.org/TR/vc-data-model/#issuer
	Issuer *string `protobuf:"bytes,3,opt,name=issuer,proto3,oneof" json:"issuer,omitempty"`
	// https://www.w3.org/TR/vc-data-model/#credential-subject
	CredentialSubject *BadgeClaims `protobuf:"bytes,4,opt,name=credential_subject,json=credentialSubject,proto3,oneof" json:"credential_subject,omitempty"`
	// https://www.w3.org/TR/vc-data-model/#identifiers
	Id *string `protobuf:"bytes,5,opt,name=id,proto3,oneof" json:"id,omitempty"`
	// https://www.w3.org/TR/vc-data-model/#issuance-date
	IssuanceDate *string `protobuf:"bytes,6,opt,name=issuance_date,json=issuanceDate,proto3,oneof" json:"issuance_date,omitempty"`
	// https://www.w3.org/TR/vc-data-model/#expiration
	ExpirationDate *string `protobuf:"bytes,7,opt,name=expiration_date,json=expirationDate,proto3,oneof" json:"expiration_date,omitempty"`
	// https://www.w3.org/TR/vc-data-model-2.0/#data-schemas
	CredentialSchema []*CredentialSchema `protobuf:"bytes,8,rep,name=credential_schema,json=credentialSchema,proto3" json:"credential_schema,omitempty"`
	// https://www.w3.org/TR/vc-data-model-2.0/#status
	CredentialStatus []*CredentialStatus `protobuf:"bytes,9,rep,name=credential_status,json=credentialStatus,proto3" json:"credential_status,omitempty"`
	// https://w3id.org/security#proof
	Proof         *Proof `protobuf:"bytes,10,opt,name=proof,proto3,oneof" json:"proof,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *VerifiableCredential) Reset() {
	*x = VerifiableCredential{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *VerifiableCredential) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*VerifiableCredential) ProtoMessage() {}

func (x *VerifiableCredential) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use VerifiableCredential.ProtoReflect.Descriptor instead.
func (*VerifiableCredential) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{6}
}

func (x *VerifiableCredential) GetContext() []string {
	if x != nil {
		return x.Context
	}
	return nil
}

func (x *VerifiableCredential) GetType() []string {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *VerifiableCredential) GetIssuer() string {
	if x != nil && x.Issuer != nil {
		return *x.Issuer
	}
	return ""
}

func (x *VerifiableCredential) GetCredentialSubject() *BadgeClaims {
	if x != nil {
		return x.CredentialSubject
	}
	return nil
}

func (x *VerifiableCredential) GetId() string {
	if x != nil && x.Id != nil {
		return *x.Id
	}
	return ""
}

func (x *VerifiableCredential) GetIssuanceDate() string {
	if x != nil && x.IssuanceDate != nil {
		return *x.IssuanceDate
	}
	return ""
}

func (x *VerifiableCredential) GetExpirationDate() string {
	if x != nil && x.ExpirationDate != nil {
		return *x.ExpirationDate
	}
	return ""
}

func (x *VerifiableCredential) GetCredentialSchema() []*CredentialSchema {
	if x != nil {
		return x.CredentialSchema
	}
	return nil
}

func (x *VerifiableCredential) GetCredentialStatus() []*CredentialStatus {
	if x != nil {
		return x.CredentialStatus
	}
	return nil
}

func (x *VerifiableCredential) GetProof() *Proof {
	if x != nil {
		return x.Proof
	}
	return nil
}

// The result returned from the verification process defined [here]
//
// [here]: https://www.w3.org/TR/vc-data-model-2.0/#verification
type VerificationResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A boolean status
	Status *bool `protobuf:"varint,1,opt,name=status,proto3,oneof" json:"status,omitempty"`
	// A conforming document which represents the Verifiable Credential
	Document *VerifiableCredential `protobuf:"bytes,2,opt,name=document,proto3,oneof" json:"document,omitempty"`
	// The media type of the Verifiable Credential (ex: application/vc)
	MediaType *string `protobuf:"bytes,3,opt,name=media_type,json=mediaType,proto3,oneof" json:"media_type,omitempty"`
	// The controller of the verification method associated with the securing mechanism,
	// usually it represents the issuer.
	Controller *string `protobuf:"bytes,4,opt,name=controller,proto3,oneof" json:"controller,omitempty"`
	// A controlled identifier document that is associated with the verification method
	// used to verify the securing mechanism (i,e the DID)
	ControlledIdentifierDocument *string `protobuf:"bytes,5,opt,name=controlled_identifier_document,json=controlledIdentifierDocument,proto3,oneof" json:"controlled_identifier_document,omitempty"`
	// A list represents zero or more warnings generated by the verification process
	Warnings []*ErrorInfo `protobuf:"bytes,6,rep,name=warnings,proto3" json:"warnings,omitempty"`
	// A list represents zero or more errors generated by the verification process
	Errors        []*ErrorInfo `protobuf:"bytes,7,rep,name=errors,proto3" json:"errors,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *VerificationResult) Reset() {
	*x = VerificationResult{}
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *VerificationResult) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*VerificationResult) ProtoMessage() {}

func (x *VerificationResult) ProtoReflect() protoreflect.Message {
	mi := &file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use VerificationResult.ProtoReflect.Descriptor instead.
func (*VerificationResult) Descriptor() ([]byte, []int) {
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP(), []int{7}
}

func (x *VerificationResult) GetStatus() bool {
	if x != nil && x.Status != nil {
		return *x.Status
	}
	return false
}

func (x *VerificationResult) GetDocument() *VerifiableCredential {
	if x != nil {
		return x.Document
	}
	return nil
}

func (x *VerificationResult) GetMediaType() string {
	if x != nil && x.MediaType != nil {
		return *x.MediaType
	}
	return ""
}

func (x *VerificationResult) GetController() string {
	if x != nil && x.Controller != nil {
		return *x.Controller
	}
	return ""
}

func (x *VerificationResult) GetControlledIdentifierDocument() string {
	if x != nil && x.ControlledIdentifierDocument != nil {
		return *x.ControlledIdentifierDocument
	}
	return ""
}

func (x *VerificationResult) GetWarnings() []*ErrorInfo {
	if x != nil {
		return x.Warnings
	}
	return nil
}

func (x *VerificationResult) GetErrors() []*ErrorInfo {
	if x != nil {
		return x.Errors
	}
	return nil
}

var File_agntcy_identity_service_v1alpha1_badge_proto protoreflect.FileDescriptor

const file_agntcy_identity_service_v1alpha1_badge_proto_rawDesc = "" +
	"\n" +
	",agntcy/identity/service/v1alpha1/badge.proto\x12 agntcy.identity.service.v1alpha1\x1a\x1fgoogle/protobuf/timestamp.proto\"\xba\x01\n" +
	"\x05Badge\x12p\n" +
	"\x15verifiable_credential\x18\x01 \x01(\v26.agntcy.identity.service.v1alpha1.VerifiableCredentialH\x00R\x14verifiableCredential\x88\x01\x01\x12\x1a\n" +
	"\x06app_id\x18\x02 \x01(\tH\x01R\x05appId\x88\x01\x01B\x18\n" +
	"\x16_verifiable_credentialB\t\n" +
	"\a_app_id\"N\n" +
	"\vBadgeClaims\x12\x13\n" +
	"\x02id\x18\x01 \x01(\tH\x00R\x02id\x88\x01\x01\x12\x19\n" +
	"\x05badge\x18\x02 \x01(\tH\x01R\x05badge\x88\x01\x01B\x05\n" +
	"\x03_idB\b\n" +
	"\x06_badge\"P\n" +
	"\x10CredentialSchema\x12\x17\n" +
	"\x04type\x18\x01 \x01(\tH\x00R\x04type\x88\x01\x01\x12\x13\n" +
	"\x02id\x18\x02 \x01(\tH\x01R\x02id\x88\x01\x01B\a\n" +
	"\x05_typeB\x05\n" +
	"\x03_id\"\x85\x02\n" +
	"\x10CredentialStatus\x12\x13\n" +
	"\x02id\x18\x01 \x01(\tH\x00R\x02id\x88\x01\x01\x12\x17\n" +
	"\x04type\x18\x02 \x01(\tH\x01R\x04type\x88\x01\x01\x12>\n" +
	"\n" +
	"created_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampH\x02R\tcreatedAt\x88\x01\x01\x12X\n" +
	"\apurpose\x18\x04 \x01(\x0e29.agntcy.identity.service.v1alpha1.CredentialStatusPurposeH\x03R\apurpose\x88\x01\x01B\x05\n" +
	"\x03_idB\a\n" +
	"\x05_typeB\r\n" +
	"\v_created_atB\n" +
	"\n" +
	"\b_purpose\"^\n" +
	"\tErrorInfo\x12\x1b\n" +
	"\x06reason\x18\x01 \x01(\tH\x00R\x06reason\x88\x01\x01\x12\x1d\n" +
	"\amessage\x18\x02 \x01(\tH\x01R\amessage\x88\x01\x01B\t\n" +
	"\a_reasonB\n" +
	"\n" +
	"\b_message\"\x9b\x01\n" +
	"\x05Proof\x12\x17\n" +
	"\x04type\x18\x01 \x01(\tH\x00R\x04type\x88\x01\x01\x12(\n" +
	"\rproof_purpose\x18\x02 \x01(\tH\x01R\fproofPurpose\x88\x01\x01\x12$\n" +
	"\vproof_value\x18\x03 \x01(\tH\x02R\n" +
	"proofValue\x88\x01\x01B\a\n" +
	"\x05_typeB\x10\n" +
	"\x0e_proof_purposeB\x0e\n" +
	"\f_proof_value\"\x90\x05\n" +
	"\x14VerifiableCredential\x12\x18\n" +
	"\acontext\x18\x01 \x03(\tR\acontext\x12\x12\n" +
	"\x04type\x18\x02 \x03(\tR\x04type\x12\x1b\n" +
	"\x06issuer\x18\x03 \x01(\tH\x00R\x06issuer\x88\x01\x01\x12a\n" +
	"\x12credential_subject\x18\x04 \x01(\v2-.agntcy.identity.service.v1alpha1.BadgeClaimsH\x01R\x11credentialSubject\x88\x01\x01\x12\x13\n" +
	"\x02id\x18\x05 \x01(\tH\x02R\x02id\x88\x01\x01\x12(\n" +
	"\rissuance_date\x18\x06 \x01(\tH\x03R\fissuanceDate\x88\x01\x01\x12,\n" +
	"\x0fexpiration_date\x18\a \x01(\tH\x04R\x0eexpirationDate\x88\x01\x01\x12_\n" +
	"\x11credential_schema\x18\b \x03(\v22.agntcy.identity.service.v1alpha1.CredentialSchemaR\x10credentialSchema\x12_\n" +
	"\x11credential_status\x18\t \x03(\v22.agntcy.identity.service.v1alpha1.CredentialStatusR\x10credentialStatus\x12B\n" +
	"\x05proof\x18\n" +
	" \x01(\v2'.agntcy.identity.service.v1alpha1.ProofH\x05R\x05proof\x88\x01\x01B\t\n" +
	"\a_issuerB\x15\n" +
	"\x13_credential_subjectB\x05\n" +
	"\x03_idB\x10\n" +
	"\x0e_issuance_dateB\x12\n" +
	"\x10_expiration_dateB\b\n" +
	"\x06_proof\"\x85\x04\n" +
	"\x12VerificationResult\x12\x1b\n" +
	"\x06status\x18\x01 \x01(\bH\x00R\x06status\x88\x01\x01\x12W\n" +
	"\bdocument\x18\x02 \x01(\v26.agntcy.identity.service.v1alpha1.VerifiableCredentialH\x01R\bdocument\x88\x01\x01\x12\"\n" +
	"\n" +
	"media_type\x18\x03 \x01(\tH\x02R\tmediaType\x88\x01\x01\x12#\n" +
	"\n" +
	"controller\x18\x04 \x01(\tH\x03R\n" +
	"controller\x88\x01\x01\x12I\n" +
	"\x1econtrolled_identifier_document\x18\x05 \x01(\tH\x04R\x1ccontrolledIdentifierDocument\x88\x01\x01\x12G\n" +
	"\bwarnings\x18\x06 \x03(\v2+.agntcy.identity.service.v1alpha1.ErrorInfoR\bwarnings\x12C\n" +
	"\x06errors\x18\a \x03(\v2+.agntcy.identity.service.v1alpha1.ErrorInfoR\x06errorsB\t\n" +
	"\a_statusB\v\n" +
	"\t_documentB\r\n" +
	"\v_media_typeB\r\n" +
	"\v_controllerB!\n" +
	"\x1f_controlled_identifier_document*]\n" +
	"\tBadgeType\x12\x1a\n" +
	"\x16BADGE_TYPE_UNSPECIFIED\x10\x00\x12\x1a\n" +
	"\x16BADGE_TYPE_AGENT_BADGE\x10\x01\x12\x18\n" +
	"\x14BADGE_TYPE_MCP_BADGE\x10\x02*n\n" +
	"\x17CredentialStatusPurpose\x12)\n" +
	"%CREDENTIAL_STATUS_PURPOSE_UNSPECIFIED\x10\x00\x12(\n" +
	"$CREDENTIAL_STATUS_PURPOSE_REVOCATION\x10\x01BhZfgithub.com/agntcy/identity-service/api/server/agntcy/identity/service/v1alpha1;identity_service_sdk_gob\x06proto3"

var (
	file_agntcy_identity_service_v1alpha1_badge_proto_rawDescOnce sync.Once
	file_agntcy_identity_service_v1alpha1_badge_proto_rawDescData []byte
)

func file_agntcy_identity_service_v1alpha1_badge_proto_rawDescGZIP() []byte {
	file_agntcy_identity_service_v1alpha1_badge_proto_rawDescOnce.Do(func() {
		file_agntcy_identity_service_v1alpha1_badge_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_agntcy_identity_service_v1alpha1_badge_proto_rawDesc), len(file_agntcy_identity_service_v1alpha1_badge_proto_rawDesc)))
	})
	return file_agntcy_identity_service_v1alpha1_badge_proto_rawDescData
}

var file_agntcy_identity_service_v1alpha1_badge_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes = make([]protoimpl.MessageInfo, 8)
var file_agntcy_identity_service_v1alpha1_badge_proto_goTypes = []any{
	(BadgeType)(0),                // 0: agntcy.identity.service.v1alpha1.BadgeType
	(CredentialStatusPurpose)(0),  // 1: agntcy.identity.service.v1alpha1.CredentialStatusPurpose
	(*Badge)(nil),                 // 2: agntcy.identity.service.v1alpha1.Badge
	(*BadgeClaims)(nil),           // 3: agntcy.identity.service.v1alpha1.BadgeClaims
	(*CredentialSchema)(nil),      // 4: agntcy.identity.service.v1alpha1.CredentialSchema
	(*CredentialStatus)(nil),      // 5: agntcy.identity.service.v1alpha1.CredentialStatus
	(*ErrorInfo)(nil),             // 6: agntcy.identity.service.v1alpha1.ErrorInfo
	(*Proof)(nil),                 // 7: agntcy.identity.service.v1alpha1.Proof
	(*VerifiableCredential)(nil),  // 8: agntcy.identity.service.v1alpha1.VerifiableCredential
	(*VerificationResult)(nil),    // 9: agntcy.identity.service.v1alpha1.VerificationResult
	(*timestamppb.Timestamp)(nil), // 10: google.protobuf.Timestamp
}
var file_agntcy_identity_service_v1alpha1_badge_proto_depIdxs = []int32{
	8,  // 0: agntcy.identity.service.v1alpha1.Badge.verifiable_credential:type_name -> agntcy.identity.service.v1alpha1.VerifiableCredential
	10, // 1: agntcy.identity.service.v1alpha1.CredentialStatus.created_at:type_name -> google.protobuf.Timestamp
	1,  // 2: agntcy.identity.service.v1alpha1.CredentialStatus.purpose:type_name -> agntcy.identity.service.v1alpha1.CredentialStatusPurpose
	3,  // 3: agntcy.identity.service.v1alpha1.VerifiableCredential.credential_subject:type_name -> agntcy.identity.service.v1alpha1.BadgeClaims
	4,  // 4: agntcy.identity.service.v1alpha1.VerifiableCredential.credential_schema:type_name -> agntcy.identity.service.v1alpha1.CredentialSchema
	5,  // 5: agntcy.identity.service.v1alpha1.VerifiableCredential.credential_status:type_name -> agntcy.identity.service.v1alpha1.CredentialStatus
	7,  // 6: agntcy.identity.service.v1alpha1.VerifiableCredential.proof:type_name -> agntcy.identity.service.v1alpha1.Proof
	8,  // 7: agntcy.identity.service.v1alpha1.VerificationResult.document:type_name -> agntcy.identity.service.v1alpha1.VerifiableCredential
	6,  // 8: agntcy.identity.service.v1alpha1.VerificationResult.warnings:type_name -> agntcy.identity.service.v1alpha1.ErrorInfo
	6,  // 9: agntcy.identity.service.v1alpha1.VerificationResult.errors:type_name -> agntcy.identity.service.v1alpha1.ErrorInfo
	10, // [10:10] is the sub-list for method output_type
	10, // [10:10] is the sub-list for method input_type
	10, // [10:10] is the sub-list for extension type_name
	10, // [10:10] is the sub-list for extension extendee
	0,  // [0:10] is the sub-list for field type_name
}

func init() { file_agntcy_identity_service_v1alpha1_badge_proto_init() }
func file_agntcy_identity_service_v1alpha1_badge_proto_init() {
	if File_agntcy_identity_service_v1alpha1_badge_proto != nil {
		return
	}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[0].OneofWrappers = []any{}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[1].OneofWrappers = []any{}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[2].OneofWrappers = []any{}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[3].OneofWrappers = []any{}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[4].OneofWrappers = []any{}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[5].OneofWrappers = []any{}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[6].OneofWrappers = []any{}
	file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes[7].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_agntcy_identity_service_v1alpha1_badge_proto_rawDesc), len(file_agntcy_identity_service_v1alpha1_badge_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   8,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_agntcy_identity_service_v1alpha1_badge_proto_goTypes,
		DependencyIndexes: file_agntcy_identity_service_v1alpha1_badge_proto_depIdxs,
		EnumInfos:         file_agntcy_identity_service_v1alpha1_badge_proto_enumTypes,
		MessageInfos:      file_agntcy_identity_service_v1alpha1_badge_proto_msgTypes,
	}.Build()
	File_agntcy_identity_service_v1alpha1_badge_proto = out.File
	file_agntcy_identity_service_v1alpha1_badge_proto_goTypes = nil
	file_agntcy_identity_service_v1alpha1_badge_proto_depIdxs = nil
}
