// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v3.21.12
// source: keymanager/km_common/proto/key_claims.proto

package keymanager

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	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)
)

type KeyType int32

const (
	KeyType_KEY_TYPE_UNSPECIFIED KeyType = 0
	// A standard HPKE binding key-pair used for internal isolation.
	KeyType_KEY_TYPE_VM_PROTECTION_BINDING KeyType = 1
	// A KEM key-pair managed by the Key Protection Service.
	KeyType_KEY_TYPE_VM_PROTECTION_KEY KeyType = 2
)

// Enum value maps for KeyType.
var (
	KeyType_name = map[int32]string{
		0: "KEY_TYPE_UNSPECIFIED",
		1: "KEY_TYPE_VM_PROTECTION_BINDING",
		2: "KEY_TYPE_VM_PROTECTION_KEY",
	}
	KeyType_value = map[string]int32{
		"KEY_TYPE_UNSPECIFIED":           0,
		"KEY_TYPE_VM_PROTECTION_BINDING": 1,
		"KEY_TYPE_VM_PROTECTION_KEY":     2,
	}
)

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

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

func (KeyType) Descriptor() protoreflect.EnumDescriptor {
	return file_keymanager_km_common_proto_key_claims_proto_enumTypes[0].Descriptor()
}

func (KeyType) Type() protoreflect.EnumType {
	return &file_keymanager_km_common_proto_key_claims_proto_enumTypes[0]
}

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

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

type KeyProtectionMechanism int32

const (
	KeyProtectionMechanism_KEY_PROTECTION_MECHANISM_UNSPECIFIED KeyProtectionMechanism = 0
	// The key is held by the Workload Services Daemon, and is endorsed by a single CVM
	// attestation.
	KeyProtectionMechanism_DEFAULT KeyProtectionMechanism = 1
	// The key is held by the Key Protection Services VM, and is endorsed by a pair of CVM
	// attestations, from the Workload Services Daemon and Key Protection VM.
	KeyProtectionMechanism_KEY_PROTECTION_VM KeyProtectionMechanism = 2
	// An interim solution where the key is held by the Workload Services Daemon emulating
	// the Key Protection Service. It is endorsed by a single CVM attestation.
	KeyProtectionMechanism_KEY_PROTECTION_VM_EMULATED KeyProtectionMechanism = 3
)

// Enum value maps for KeyProtectionMechanism.
var (
	KeyProtectionMechanism_name = map[int32]string{
		0: "KEY_PROTECTION_MECHANISM_UNSPECIFIED",
		1: "DEFAULT",
		2: "KEY_PROTECTION_VM",
		3: "KEY_PROTECTION_VM_EMULATED",
	}
	KeyProtectionMechanism_value = map[string]int32{
		"KEY_PROTECTION_MECHANISM_UNSPECIFIED": 0,
		"DEFAULT":                              1,
		"KEY_PROTECTION_VM":                    2,
		"KEY_PROTECTION_VM_EMULATED":           3,
	}
)

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

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

func (KeyProtectionMechanism) Descriptor() protoreflect.EnumDescriptor {
	return file_keymanager_km_common_proto_key_claims_proto_enumTypes[1].Descriptor()
}

func (KeyProtectionMechanism) Type() protoreflect.EnumType {
	return &file_keymanager_km_common_proto_key_claims_proto_enumTypes[1]
}

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

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

// Used to refer to key instances held by various daemons.
type KeyHandle struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Handle        string                 `protobuf:"bytes,1,opt,name=handle,proto3" json:"handle,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KeyHandle) ProtoMessage() {}

func (x *KeyHandle) ProtoReflect() protoreflect.Message {
	mi := &file_keymanager_km_common_proto_key_claims_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 KeyHandle.ProtoReflect.Descriptor instead.
func (*KeyHandle) Descriptor() ([]byte, []int) {
	return file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP(), []int{0}
}

func (x *KeyHandle) GetHandle() string {
	if x != nil {
		return x.Handle
	}
	return ""
}

// GetKeyClaimsRequest defines the input required to retrieve claims for a key.
type GetKeyClaimsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique identifier (UUID) for the key.
	KeyHandle *KeyHandle `protobuf:"bytes,1,opt,name=key_handle,json=keyHandle,proto3" json:"key_handle,omitempty"`
	// The type of key (Binding or KEM) which determines the claim format.
	KeyType       KeyType `protobuf:"varint,2,opt,name=key_type,json=keyType,proto3,enum=keymanager.KeyType" json:"key_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetKeyClaimsRequest) ProtoMessage() {}

func (x *GetKeyClaimsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_keymanager_km_common_proto_key_claims_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 GetKeyClaimsRequest.ProtoReflect.Descriptor instead.
func (*GetKeyClaimsRequest) Descriptor() ([]byte, []int) {
	return file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP(), []int{1}
}

func (x *GetKeyClaimsRequest) GetKeyHandle() *KeyHandle {
	if x != nil {
		return x.KeyHandle
	}
	return nil
}

func (x *GetKeyClaimsRequest) GetKeyType() KeyType {
	if x != nil {
		return x.KeyType
	}
	return KeyType_KEY_TYPE_UNSPECIFIED
}

type KemPublicKey struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Algorithm     KemAlgorithm           `protobuf:"varint,1,opt,name=algorithm,proto3,enum=keymanager.KemAlgorithm" json:"algorithm,omitempty"`
	PublicKey     []byte                 `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` // `Npk` bytes long; see the KemAlgorithm definition.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KemPublicKey) ProtoMessage() {}

func (x *KemPublicKey) ProtoReflect() protoreflect.Message {
	mi := &file_keymanager_km_common_proto_key_claims_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 KemPublicKey.ProtoReflect.Descriptor instead.
func (*KemPublicKey) Descriptor() ([]byte, []int) {
	return file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP(), []int{2}
}

func (x *KemPublicKey) GetAlgorithm() KemAlgorithm {
	if x != nil {
		return x.Algorithm
	}
	return KemAlgorithm_KEM_ALGORITHM_UNSPECIFIED
}

func (x *KemPublicKey) GetPublicKey() []byte {
	if x != nil {
		return x.PublicKey
	}
	return nil
}

type HpkePublicKey struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Algorithm     *HpkeAlgorithm         `protobuf:"bytes,1,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
	PublicKey     []byte                 `protobuf:"bytes,2,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"` // `Npk` bytes long. Raw bytes.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HpkePublicKey) ProtoMessage() {}

func (x *HpkePublicKey) ProtoReflect() protoreflect.Message {
	mi := &file_keymanager_km_common_proto_key_claims_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 HpkePublicKey.ProtoReflect.Descriptor instead.
func (*HpkePublicKey) Descriptor() ([]byte, []int) {
	return file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP(), []int{3}
}

func (x *HpkePublicKey) GetAlgorithm() *HpkeAlgorithm {
	if x != nil {
		return x.Algorithm
	}
	return nil
}

func (x *HpkePublicKey) GetPublicKey() []byte {
	if x != nil {
		return x.PublicKey
	}
	return nil
}

type KeyClaims struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Claims:
	//
	//	*KeyClaims_VmBindingClaims
	//	*KeyClaims_VmKeyClaims
	Claims        isKeyClaims_Claims `protobuf_oneof:"claims"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KeyClaims) ProtoMessage() {}

func (x *KeyClaims) ProtoReflect() protoreflect.Message {
	mi := &file_keymanager_km_common_proto_key_claims_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 KeyClaims.ProtoReflect.Descriptor instead.
func (*KeyClaims) Descriptor() ([]byte, []int) {
	return file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP(), []int{4}
}

func (x *KeyClaims) GetClaims() isKeyClaims_Claims {
	if x != nil {
		return x.Claims
	}
	return nil
}

func (x *KeyClaims) GetVmBindingClaims() *KeyClaims_VmProtectionBindingClaims {
	if x != nil {
		if x, ok := x.Claims.(*KeyClaims_VmBindingClaims); ok {
			return x.VmBindingClaims
		}
	}
	return nil
}

func (x *KeyClaims) GetVmKeyClaims() *KeyClaims_VmProtectionKeyClaims {
	if x != nil {
		if x, ok := x.Claims.(*KeyClaims_VmKeyClaims); ok {
			return x.VmKeyClaims
		}
	}
	return nil
}

type isKeyClaims_Claims interface {
	isKeyClaims_Claims()
}

type KeyClaims_VmBindingClaims struct {
	VmBindingClaims *KeyClaims_VmProtectionBindingClaims `protobuf:"bytes,1,opt,name=vm_binding_claims,json=vmBindingClaims,proto3,oneof"`
}

type KeyClaims_VmKeyClaims struct {
	VmKeyClaims *KeyClaims_VmProtectionKeyClaims `protobuf:"bytes,2,opt,name=vm_key_claims,json=vmKeyClaims,proto3,oneof"`
}

func (*KeyClaims_VmBindingClaims) isKeyClaims_Claims() {}

func (*KeyClaims_VmKeyClaims) isKeyClaims_Claims() {}

type KeyClaims_VmProtectionBindingClaims struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The workload attests that it controls the corresponding private key.
	BindingPubKey *HpkePublicKey `protobuf:"bytes,1,opt,name=binding_pub_key,json=bindingPubKey,proto3" json:"binding_pub_key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*KeyClaims_VmProtectionBindingClaims) ProtoMessage() {}

func (x *KeyClaims_VmProtectionBindingClaims) ProtoReflect() protoreflect.Message {
	mi := &file_keymanager_km_common_proto_key_claims_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 KeyClaims_VmProtectionBindingClaims.ProtoReflect.Descriptor instead.
func (*KeyClaims_VmProtectionBindingClaims) Descriptor() ([]byte, []int) {
	return file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP(), []int{4, 0}
}

func (x *KeyClaims_VmProtectionBindingClaims) GetBindingPubKey() *HpkePublicKey {
	if x != nil {
		return x.BindingPubKey
	}
	return nil
}

type KeyClaims_VmProtectionKeyClaims struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The Key Protection Service attests that it controls the KEM private key, and that
	// it will encrypt all resulting shared secrets to the binding key.
	KemPubKey     *KemPublicKey  `protobuf:"bytes,1,opt,name=kem_pub_key,json=kemPubKey,proto3" json:"kem_pub_key,omitempty"`
	BindingPubKey *HpkePublicKey `protobuf:"bytes,2,opt,name=binding_pub_key,json=bindingPubKey,proto3" json:"binding_pub_key,omitempty"`
	// The remaining time until the Key Protection Service will autonomously delete its
	// KEM keypair.
	RemainingLifespan *durationpb.Duration `protobuf:"bytes,3,opt,name=remaining_lifespan,json=remainingLifespan,proto3" json:"remaining_lifespan,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*KeyClaims_VmProtectionKeyClaims) ProtoMessage() {}

func (x *KeyClaims_VmProtectionKeyClaims) ProtoReflect() protoreflect.Message {
	mi := &file_keymanager_km_common_proto_key_claims_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 KeyClaims_VmProtectionKeyClaims.ProtoReflect.Descriptor instead.
func (*KeyClaims_VmProtectionKeyClaims) Descriptor() ([]byte, []int) {
	return file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP(), []int{4, 1}
}

func (x *KeyClaims_VmProtectionKeyClaims) GetKemPubKey() *KemPublicKey {
	if x != nil {
		return x.KemPubKey
	}
	return nil
}

func (x *KeyClaims_VmProtectionKeyClaims) GetBindingPubKey() *HpkePublicKey {
	if x != nil {
		return x.BindingPubKey
	}
	return nil
}

func (x *KeyClaims_VmProtectionKeyClaims) GetRemainingLifespan() *durationpb.Duration {
	if x != nil {
		return x.RemainingLifespan
	}
	return nil
}

var File_keymanager_km_common_proto_key_claims_proto protoreflect.FileDescriptor

const file_keymanager_km_common_proto_key_claims_proto_rawDesc = "" +
	"\n" +
	"+keymanager/km_common/proto/key_claims.proto\x12\n" +
	"keymanager\x1a\x1egoogle/protobuf/duration.proto\x1a+keymanager/km_common/proto/algorithms.proto\"#\n" +
	"\tKeyHandle\x12\x16\n" +
	"\x06handle\x18\x01 \x01(\tR\x06handle\"{\n" +
	"\x13GetKeyClaimsRequest\x124\n" +
	"\n" +
	"key_handle\x18\x01 \x01(\v2\x15.keymanager.KeyHandleR\tkeyHandle\x12.\n" +
	"\bkey_type\x18\x02 \x01(\x0e2\x13.keymanager.KeyTypeR\akeyType\"e\n" +
	"\fKemPublicKey\x126\n" +
	"\talgorithm\x18\x01 \x01(\x0e2\x18.keymanager.KemAlgorithmR\talgorithm\x12\x1d\n" +
	"\n" +
	"public_key\x18\x02 \x01(\fR\tpublicKey\"g\n" +
	"\rHpkePublicKey\x127\n" +
	"\talgorithm\x18\x01 \x01(\v2\x19.keymanager.HpkeAlgorithmR\talgorithm\x12\x1d\n" +
	"\n" +
	"public_key\x18\x02 \x01(\fR\tpublicKey\"\x88\x04\n" +
	"\tKeyClaims\x12]\n" +
	"\x11vm_binding_claims\x18\x01 \x01(\v2/.keymanager.KeyClaims.VmProtectionBindingClaimsH\x00R\x0fvmBindingClaims\x12Q\n" +
	"\rvm_key_claims\x18\x02 \x01(\v2+.keymanager.KeyClaims.VmProtectionKeyClaimsH\x00R\vvmKeyClaims\x1a^\n" +
	"\x19VmProtectionBindingClaims\x12A\n" +
	"\x0fbinding_pub_key\x18\x01 \x01(\v2\x19.keymanager.HpkePublicKeyR\rbindingPubKey\x1a\xde\x01\n" +
	"\x15VmProtectionKeyClaims\x128\n" +
	"\vkem_pub_key\x18\x01 \x01(\v2\x18.keymanager.KemPublicKeyR\tkemPubKey\x12A\n" +
	"\x0fbinding_pub_key\x18\x02 \x01(\v2\x19.keymanager.HpkePublicKeyR\rbindingPubKey\x12H\n" +
	"\x12remaining_lifespan\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\x11remainingLifespanB\b\n" +
	"\x06claims*g\n" +
	"\aKeyType\x12\x18\n" +
	"\x14KEY_TYPE_UNSPECIFIED\x10\x00\x12\"\n" +
	"\x1eKEY_TYPE_VM_PROTECTION_BINDING\x10\x01\x12\x1e\n" +
	"\x1aKEY_TYPE_VM_PROTECTION_KEY\x10\x02*\x86\x01\n" +
	"\x16KeyProtectionMechanism\x12(\n" +
	"$KEY_PROTECTION_MECHANISM_UNSPECIFIED\x10\x00\x12\v\n" +
	"\aDEFAULT\x10\x01\x12\x15\n" +
	"\x11KEY_PROTECTION_VM\x10\x02\x12\x1e\n" +
	"\x1aKEY_PROTECTION_VM_EMULATED\x10\x03BFZDgithub.com/google/go-tpm-tools/keymanager/km_common/proto;keymanagerb\x06proto3"

var (
	file_keymanager_km_common_proto_key_claims_proto_rawDescOnce sync.Once
	file_keymanager_km_common_proto_key_claims_proto_rawDescData []byte
)

func file_keymanager_km_common_proto_key_claims_proto_rawDescGZIP() []byte {
	file_keymanager_km_common_proto_key_claims_proto_rawDescOnce.Do(func() {
		file_keymanager_km_common_proto_key_claims_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_keymanager_km_common_proto_key_claims_proto_rawDesc), len(file_keymanager_km_common_proto_key_claims_proto_rawDesc)))
	})
	return file_keymanager_km_common_proto_key_claims_proto_rawDescData
}

var file_keymanager_km_common_proto_key_claims_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_keymanager_km_common_proto_key_claims_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
var file_keymanager_km_common_proto_key_claims_proto_goTypes = []any{
	(KeyType)(0),                                // 0: keymanager.KeyType
	(KeyProtectionMechanism)(0),                 // 1: keymanager.KeyProtectionMechanism
	(*KeyHandle)(nil),                           // 2: keymanager.KeyHandle
	(*GetKeyClaimsRequest)(nil),                 // 3: keymanager.GetKeyClaimsRequest
	(*KemPublicKey)(nil),                        // 4: keymanager.KemPublicKey
	(*HpkePublicKey)(nil),                       // 5: keymanager.HpkePublicKey
	(*KeyClaims)(nil),                           // 6: keymanager.KeyClaims
	(*KeyClaims_VmProtectionBindingClaims)(nil), // 7: keymanager.KeyClaims.VmProtectionBindingClaims
	(*KeyClaims_VmProtectionKeyClaims)(nil),     // 8: keymanager.KeyClaims.VmProtectionKeyClaims
	(KemAlgorithm)(0),                           // 9: keymanager.KemAlgorithm
	(*HpkeAlgorithm)(nil),                       // 10: keymanager.HpkeAlgorithm
	(*durationpb.Duration)(nil),                 // 11: google.protobuf.Duration
}
var file_keymanager_km_common_proto_key_claims_proto_depIdxs = []int32{
	2,  // 0: keymanager.GetKeyClaimsRequest.key_handle:type_name -> keymanager.KeyHandle
	0,  // 1: keymanager.GetKeyClaimsRequest.key_type:type_name -> keymanager.KeyType
	9,  // 2: keymanager.KemPublicKey.algorithm:type_name -> keymanager.KemAlgorithm
	10, // 3: keymanager.HpkePublicKey.algorithm:type_name -> keymanager.HpkeAlgorithm
	7,  // 4: keymanager.KeyClaims.vm_binding_claims:type_name -> keymanager.KeyClaims.VmProtectionBindingClaims
	8,  // 5: keymanager.KeyClaims.vm_key_claims:type_name -> keymanager.KeyClaims.VmProtectionKeyClaims
	5,  // 6: keymanager.KeyClaims.VmProtectionBindingClaims.binding_pub_key:type_name -> keymanager.HpkePublicKey
	4,  // 7: keymanager.KeyClaims.VmProtectionKeyClaims.kem_pub_key:type_name -> keymanager.KemPublicKey
	5,  // 8: keymanager.KeyClaims.VmProtectionKeyClaims.binding_pub_key:type_name -> keymanager.HpkePublicKey
	11, // 9: keymanager.KeyClaims.VmProtectionKeyClaims.remaining_lifespan:type_name -> google.protobuf.Duration
	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_keymanager_km_common_proto_key_claims_proto_init() }
func file_keymanager_km_common_proto_key_claims_proto_init() {
	if File_keymanager_km_common_proto_key_claims_proto != nil {
		return
	}
	file_keymanager_km_common_proto_algorithms_proto_init()
	file_keymanager_km_common_proto_key_claims_proto_msgTypes[4].OneofWrappers = []any{
		(*KeyClaims_VmBindingClaims)(nil),
		(*KeyClaims_VmKeyClaims)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_keymanager_km_common_proto_key_claims_proto_rawDesc), len(file_keymanager_km_common_proto_key_claims_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   7,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_keymanager_km_common_proto_key_claims_proto_goTypes,
		DependencyIndexes: file_keymanager_km_common_proto_key_claims_proto_depIdxs,
		EnumInfos:         file_keymanager_km_common_proto_key_claims_proto_enumTypes,
		MessageInfos:      file_keymanager_km_common_proto_key_claims_proto_msgTypes,
	}.Build()
	File_keymanager_km_common_proto_key_claims_proto = out.File
	file_keymanager_km_common_proto_key_claims_proto_goTypes = nil
	file_keymanager_km_common_proto_key_claims_proto_depIdxs = nil
}
