// Copyright 2022 The Sigstore Authors.
//
// 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 protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v7.34.1
// source: sigstore_common.proto

package v1

import (
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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)
)

// Only a subset of the secure hash standard algorithms are supported.
// See <https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf> for more
// details.
// UNSPECIFIED SHOULD not be used, primary reason for inclusion is to force
// any proto JSON serialization to emit the used hash algorithm, as default
// option is to *omit* the default value of an enum (which is the first
// value, represented by '0'.
type HashAlgorithm int32

const (
	HashAlgorithm_HASH_ALGORITHM_UNSPECIFIED HashAlgorithm = 0
	HashAlgorithm_SHA2_256                   HashAlgorithm = 1
	HashAlgorithm_SHA2_384                   HashAlgorithm = 2
	HashAlgorithm_SHA2_512                   HashAlgorithm = 3
	// Used for LMS
	//
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	HashAlgorithm_SHA3_256 HashAlgorithm = 4
	// Used for LMS
	//
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	HashAlgorithm_SHA3_384 HashAlgorithm = 5
)

// Enum value maps for HashAlgorithm.
var (
	HashAlgorithm_name = map[int32]string{
		0: "HASH_ALGORITHM_UNSPECIFIED",
		1: "SHA2_256",
		2: "SHA2_384",
		3: "SHA2_512",
		4: "SHA3_256",
		5: "SHA3_384",
	}
	HashAlgorithm_value = map[string]int32{
		"HASH_ALGORITHM_UNSPECIFIED": 0,
		"SHA2_256":                   1,
		"SHA2_384":                   2,
		"SHA2_512":                   3,
		"SHA3_256":                   4,
		"SHA3_384":                   5,
	}
)

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

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

func (HashAlgorithm) Descriptor() protoreflect.EnumDescriptor {
	return file_sigstore_common_proto_enumTypes[0].Descriptor()
}

func (HashAlgorithm) Type() protoreflect.EnumType {
	return &file_sigstore_common_proto_enumTypes[0]
}

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

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

// Details of a specific public key, capturing the the key encoding method,
// and signature algorithm.
//
// PublicKeyDetails captures the public key/hash algorithm combinations
// recommended in the Sigstore ecosystem.
//
// This is modelled as a linear set as we want to provide a small number of
// opinionated options instead of allowing every possible permutation.
//
// Any changes to this enum MUST be reflected in the algorithm registry.
//
// See: <https://github.com/sigstore/architecture-docs/blob/main/algorithm-registry.md>
//
// To avoid the possibility of contradicting formats such as PKCS1 with
// ED25519 the valid permutations are listed as a linear set instead of a
// cartesian set (i.e one combined variable instead of two, one for encoding
// and one for the signature algorithm).
type PublicKeyDetails int32

const (
	PublicKeyDetails_PUBLIC_KEY_DETAILS_UNSPECIFIED PublicKeyDetails = 0
	// RSA
	//
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_PKCS1_RSA_PKCS1V5 PublicKeyDetails = 1 // See RFC8017
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_PKCS1_RSA_PSS PublicKeyDetails = 2 // See RFC8017
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_PKIX_RSA_PKCS1V5 PublicKeyDetails = 3
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_PKIX_RSA_PSS PublicKeyDetails = 4
	// RSA public key in PKIX format, PKCS#1v1.5 signature
	PublicKeyDetails_PKIX_RSA_PKCS1V15_2048_SHA256 PublicKeyDetails = 9
	PublicKeyDetails_PKIX_RSA_PKCS1V15_3072_SHA256 PublicKeyDetails = 10
	PublicKeyDetails_PKIX_RSA_PKCS1V15_4096_SHA256 PublicKeyDetails = 11
	// RSA public key in PKIX format, RSASSA-PSS signature
	PublicKeyDetails_PKIX_RSA_PSS_2048_SHA256 PublicKeyDetails = 16 // See RFC4055
	PublicKeyDetails_PKIX_RSA_PSS_3072_SHA256 PublicKeyDetails = 17
	PublicKeyDetails_PKIX_RSA_PSS_4096_SHA256 PublicKeyDetails = 18
	// ECDSA
	//
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_PKIX_ECDSA_P256_HMAC_SHA_256 PublicKeyDetails = 6 // See RFC6979
	PublicKeyDetails_PKIX_ECDSA_P256_SHA_256      PublicKeyDetails = 5 // See NIST FIPS 186-4
	PublicKeyDetails_PKIX_ECDSA_P384_SHA_384      PublicKeyDetails = 12
	PublicKeyDetails_PKIX_ECDSA_P521_SHA_512      PublicKeyDetails = 13
	// Ed 25519
	PublicKeyDetails_PKIX_ED25519    PublicKeyDetails = 7 // See RFC8032
	PublicKeyDetails_PKIX_ED25519_PH PublicKeyDetails = 8
	// These algorithms are deprecated and should not be used, but they
	// were/are being used by most Sigstore clients implementations.
	//
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_PKIX_ECDSA_P384_SHA_256 PublicKeyDetails = 19
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_PKIX_ECDSA_P521_SHA_256 PublicKeyDetails = 20
	// LMS and LM-OTS
	//
	// These algorithms are deprecated and should not be used.
	// There are no plans to support SLH-DSA at this time.
	//
	// USER WARNING: LMS and LM-OTS are both stateful signature schemes.
	// Using them correctly requires discretion and careful consideration
	// to ensure that individual secret keys are not used more than once.
	// In addition, LM-OTS is a single-use scheme, meaning that it
	// MUST NOT be used for more than one signature per LM-OTS key.
	// If you cannot maintain these invariants, you MUST NOT use these
	// schemes.
	//
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_LMS_SHA256 PublicKeyDetails = 14
	// Deprecated: Marked as deprecated in sigstore_common.proto.
	PublicKeyDetails_LMOTS_SHA256 PublicKeyDetails = 15
	// ML-DSA
	//
	// These ML_DSA_44, ML_DSA_65 and ML-DSA_87 algorithms are the pure variants
	// that take data to sign rather than the prehash variants (HashML-DSA), which
	// take digests. While considered quantum-resistant, their usage
	// involves tradeoffs in that signatures and keys are much larger, and
	// this makes deployments more costly.
	//
	// USER WARNING: ML_DSA_44, ML_DSA_65 and ML_DSA_87 are experimental algorithms.
	// In the future they MAY be used by private Sigstore deployments, but
	// they are not yet fully functional. This warning will be removed when
	// these algorithms are widely supported by Sigstore clients and servers,
	// but care should still be taken for production environments.
	//
	// See NIST FIPS 204, RFC 9881 for algorithm identifiers
	PublicKeyDetails_ML_DSA_44 PublicKeyDetails = 23
	PublicKeyDetails_ML_DSA_65 PublicKeyDetails = 21
	PublicKeyDetails_ML_DSA_87 PublicKeyDetails = 22
)

// Enum value maps for PublicKeyDetails.
var (
	PublicKeyDetails_name = map[int32]string{
		0:  "PUBLIC_KEY_DETAILS_UNSPECIFIED",
		1:  "PKCS1_RSA_PKCS1V5",
		2:  "PKCS1_RSA_PSS",
		3:  "PKIX_RSA_PKCS1V5",
		4:  "PKIX_RSA_PSS",
		9:  "PKIX_RSA_PKCS1V15_2048_SHA256",
		10: "PKIX_RSA_PKCS1V15_3072_SHA256",
		11: "PKIX_RSA_PKCS1V15_4096_SHA256",
		16: "PKIX_RSA_PSS_2048_SHA256",
		17: "PKIX_RSA_PSS_3072_SHA256",
		18: "PKIX_RSA_PSS_4096_SHA256",
		6:  "PKIX_ECDSA_P256_HMAC_SHA_256",
		5:  "PKIX_ECDSA_P256_SHA_256",
		12: "PKIX_ECDSA_P384_SHA_384",
		13: "PKIX_ECDSA_P521_SHA_512",
		7:  "PKIX_ED25519",
		8:  "PKIX_ED25519_PH",
		19: "PKIX_ECDSA_P384_SHA_256",
		20: "PKIX_ECDSA_P521_SHA_256",
		14: "LMS_SHA256",
		15: "LMOTS_SHA256",
		23: "ML_DSA_44",
		21: "ML_DSA_65",
		22: "ML_DSA_87",
	}
	PublicKeyDetails_value = map[string]int32{
		"PUBLIC_KEY_DETAILS_UNSPECIFIED": 0,
		"PKCS1_RSA_PKCS1V5":              1,
		"PKCS1_RSA_PSS":                  2,
		"PKIX_RSA_PKCS1V5":               3,
		"PKIX_RSA_PSS":                   4,
		"PKIX_RSA_PKCS1V15_2048_SHA256":  9,
		"PKIX_RSA_PKCS1V15_3072_SHA256":  10,
		"PKIX_RSA_PKCS1V15_4096_SHA256":  11,
		"PKIX_RSA_PSS_2048_SHA256":       16,
		"PKIX_RSA_PSS_3072_SHA256":       17,
		"PKIX_RSA_PSS_4096_SHA256":       18,
		"PKIX_ECDSA_P256_HMAC_SHA_256":   6,
		"PKIX_ECDSA_P256_SHA_256":        5,
		"PKIX_ECDSA_P384_SHA_384":        12,
		"PKIX_ECDSA_P521_SHA_512":        13,
		"PKIX_ED25519":                   7,
		"PKIX_ED25519_PH":                8,
		"PKIX_ECDSA_P384_SHA_256":        19,
		"PKIX_ECDSA_P521_SHA_256":        20,
		"LMS_SHA256":                     14,
		"LMOTS_SHA256":                   15,
		"ML_DSA_44":                      23,
		"ML_DSA_65":                      21,
		"ML_DSA_87":                      22,
	}
)

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

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

func (PublicKeyDetails) Descriptor() protoreflect.EnumDescriptor {
	return file_sigstore_common_proto_enumTypes[1].Descriptor()
}

func (PublicKeyDetails) Type() protoreflect.EnumType {
	return &file_sigstore_common_proto_enumTypes[1]
}

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

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

type SubjectAlternativeNameType int32

const (
	SubjectAlternativeNameType_SUBJECT_ALTERNATIVE_NAME_TYPE_UNSPECIFIED SubjectAlternativeNameType = 0
	SubjectAlternativeNameType_EMAIL                                     SubjectAlternativeNameType = 1
	SubjectAlternativeNameType_URI                                       SubjectAlternativeNameType = 2
	// OID 1.3.6.1.4.1.57264.1.7
	// See https://github.com/sigstore/fulcio/blob/main/docs/oid-info.md#1361415726417--othername-san
	// for more details.
	SubjectAlternativeNameType_OTHER_NAME SubjectAlternativeNameType = 3
)

// Enum value maps for SubjectAlternativeNameType.
var (
	SubjectAlternativeNameType_name = map[int32]string{
		0: "SUBJECT_ALTERNATIVE_NAME_TYPE_UNSPECIFIED",
		1: "EMAIL",
		2: "URI",
		3: "OTHER_NAME",
	}
	SubjectAlternativeNameType_value = map[string]int32{
		"SUBJECT_ALTERNATIVE_NAME_TYPE_UNSPECIFIED": 0,
		"EMAIL":      1,
		"URI":        2,
		"OTHER_NAME": 3,
	}
)

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

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

func (SubjectAlternativeNameType) Descriptor() protoreflect.EnumDescriptor {
	return file_sigstore_common_proto_enumTypes[2].Descriptor()
}

func (SubjectAlternativeNameType) Type() protoreflect.EnumType {
	return &file_sigstore_common_proto_enumTypes[2]
}

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

// Deprecated: Use SubjectAlternativeNameType.Descriptor instead.
func (SubjectAlternativeNameType) EnumDescriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{2}
}

// HashOutput captures a digest of a 'message' (generic octet sequence)
// and the corresponding hash algorithm used.
type HashOutput struct {
	state     protoimpl.MessageState `protogen:"open.v1"`
	Algorithm HashAlgorithm          `protobuf:"varint,1,opt,name=algorithm,proto3,enum=dev.sigstore.common.v1.HashAlgorithm" json:"algorithm,omitempty"`
	// This is the raw octets of the message digest as computed by
	// the hash algorithm.
	Digest        []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*HashOutput) ProtoMessage() {}

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

func (x *HashOutput) GetAlgorithm() HashAlgorithm {
	if x != nil {
		return x.Algorithm
	}
	return HashAlgorithm_HASH_ALGORITHM_UNSPECIFIED
}

func (x *HashOutput) GetDigest() []byte {
	if x != nil {
		return x.Digest
	}
	return nil
}

// MessageSignature stores the computed signature over a message.
type MessageSignature struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Message digest can be used to identify the artifact.
	// Clients MUST NOT attempt to use this digest to verify the associated
	// signature; it is intended solely for identification.
	MessageDigest *HashOutput `protobuf:"bytes,1,opt,name=message_digest,json=messageDigest,proto3" json:"message_digest,omitempty"`
	// The raw bytes as returned from the signature algorithm.
	// The signature algorithm (and so the format of the signature bytes)
	// are determined by the contents of the 'verification_material',
	// either a key-pair or a certificate. If using a certificate, the
	// certificate contains the required information on the signature
	// algorithm.
	// When using a key pair, the algorithm MUST be part of the public
	// key, which MUST be communicated out-of-band.
	Signature     []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MessageSignature) ProtoMessage() {}

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

func (x *MessageSignature) GetMessageDigest() *HashOutput {
	if x != nil {
		return x.MessageDigest
	}
	return nil
}

func (x *MessageSignature) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

// LogId captures the identity of a transparency log.
type LogId struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The unique identity of the log, represented by its public key.
	KeyId         []byte `protobuf:"bytes,1,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LogId) ProtoMessage() {}

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

func (x *LogId) GetKeyId() []byte {
	if x != nil {
		return x.KeyId
	}
	return nil
}

// This message holds a RFC 3161 timestamp.
type RFC3161SignedTimestamp struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Signed timestamp is the DER encoded TimeStampResponse.
	// See https://www.rfc-editor.org/rfc/rfc3161.html#section-2.4.2
	SignedTimestamp []byte `protobuf:"bytes,1,opt,name=signed_timestamp,json=signedTimestamp,proto3" json:"signed_timestamp,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*RFC3161SignedTimestamp) ProtoMessage() {}

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

func (x *RFC3161SignedTimestamp) GetSignedTimestamp() []byte {
	if x != nil {
		return x.SignedTimestamp
	}
	return nil
}

type PublicKey struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// DER-encoded public key, encoding method is specified by the
	// key_details attribute.
	RawBytes []byte `protobuf:"bytes,1,opt,name=raw_bytes,json=rawBytes,proto3,oneof" json:"raw_bytes,omitempty"`
	// Key encoding and signature algorithm to use for this key.
	KeyDetails PublicKeyDetails `protobuf:"varint,2,opt,name=key_details,json=keyDetails,proto3,enum=dev.sigstore.common.v1.PublicKeyDetails" json:"key_details,omitempty"`
	// Optional validity period for this key, *inclusive* of the endpoints.
	ValidFor      *TimeRange `protobuf:"bytes,3,opt,name=valid_for,json=validFor,proto3,oneof" json:"valid_for,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PublicKey) ProtoMessage() {}

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

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

func (x *PublicKey) GetKeyDetails() PublicKeyDetails {
	if x != nil {
		return x.KeyDetails
	}
	return PublicKeyDetails_PUBLIC_KEY_DETAILS_UNSPECIFIED
}

func (x *PublicKey) GetValidFor() *TimeRange {
	if x != nil {
		return x.ValidFor
	}
	return nil
}

// PublicKeyIdentifier can be used to identify an (out of band) delivered
// key, to verify a signature.
type PublicKeyIdentifier struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Optional unauthenticated hint on which key to use.
	// The format of the hint must be agreed upon out of band by the
	// signer and the verifiers, and so is not subject to this
	// specification.
	// Example use-case is to specify the public key to use, from a
	// trusted key-ring.
	// Implementors are RECOMMENDED to derive the value from the public
	// key as described in RFC 6962.
	// See: <https://www.rfc-editor.org/rfc/rfc6962#section-3.2>
	Hint          string `protobuf:"bytes,1,opt,name=hint,proto3" json:"hint,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*PublicKeyIdentifier) ProtoMessage() {}

func (x *PublicKeyIdentifier) ProtoReflect() protoreflect.Message {
	mi := &file_sigstore_common_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 PublicKeyIdentifier.ProtoReflect.Descriptor instead.
func (*PublicKeyIdentifier) Descriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{5}
}

func (x *PublicKeyIdentifier) GetHint() string {
	if x != nil {
		return x.Hint
	}
	return ""
}

// An ASN.1 OBJECT IDENTIFIER
type ObjectIdentifier struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            []int32                `protobuf:"varint,1,rep,packed,name=id,proto3" json:"id,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectIdentifier) ProtoMessage() {}

func (x *ObjectIdentifier) ProtoReflect() protoreflect.Message {
	mi := &file_sigstore_common_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 ObjectIdentifier.ProtoReflect.Descriptor instead.
func (*ObjectIdentifier) Descriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{6}
}

func (x *ObjectIdentifier) GetId() []int32 {
	if x != nil {
		return x.Id
	}
	return nil
}

// An OID and the corresponding (byte) value.
type ObjectIdentifierValuePair struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Oid           *ObjectIdentifier      `protobuf:"bytes,1,opt,name=oid,proto3" json:"oid,omitempty"`
	Value         []byte                 `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ObjectIdentifierValuePair) ProtoMessage() {}

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

func (x *ObjectIdentifierValuePair) GetOid() *ObjectIdentifier {
	if x != nil {
		return x.Oid
	}
	return nil
}

func (x *ObjectIdentifierValuePair) GetValue() []byte {
	if x != nil {
		return x.Value
	}
	return nil
}

type DistinguishedName struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Organization  string                 `protobuf:"bytes,1,opt,name=organization,proto3" json:"organization,omitempty"`
	CommonName    string                 `protobuf:"bytes,2,opt,name=common_name,json=commonName,proto3" json:"common_name,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DistinguishedName) Reset() {
	*x = DistinguishedName{}
	mi := &file_sigstore_common_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DistinguishedName) ProtoMessage() {}

func (x *DistinguishedName) ProtoReflect() protoreflect.Message {
	mi := &file_sigstore_common_proto_msgTypes[8]
	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 DistinguishedName.ProtoReflect.Descriptor instead.
func (*DistinguishedName) Descriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{8}
}

func (x *DistinguishedName) GetOrganization() string {
	if x != nil {
		return x.Organization
	}
	return ""
}

func (x *DistinguishedName) GetCommonName() string {
	if x != nil {
		return x.CommonName
	}
	return ""
}

type X509Certificate struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// DER-encoded X.509 certificate.
	RawBytes      []byte `protobuf:"bytes,1,opt,name=raw_bytes,json=rawBytes,proto3" json:"raw_bytes,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *X509Certificate) Reset() {
	*x = X509Certificate{}
	mi := &file_sigstore_common_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*X509Certificate) ProtoMessage() {}

func (x *X509Certificate) ProtoReflect() protoreflect.Message {
	mi := &file_sigstore_common_proto_msgTypes[9]
	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 X509Certificate.ProtoReflect.Descriptor instead.
func (*X509Certificate) Descriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{9}
}

func (x *X509Certificate) GetRawBytes() []byte {
	if x != nil {
		return x.RawBytes
	}
	return nil
}

type SubjectAlternativeName struct {
	state protoimpl.MessageState     `protogen:"open.v1"`
	Type  SubjectAlternativeNameType `protobuf:"varint,1,opt,name=type,proto3,enum=dev.sigstore.common.v1.SubjectAlternativeNameType" json:"type,omitempty"`
	// Types that are valid to be assigned to Identity:
	//
	//	*SubjectAlternativeName_Regexp
	//	*SubjectAlternativeName_Value
	Identity      isSubjectAlternativeName_Identity `protobuf_oneof:"identity"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SubjectAlternativeName) Reset() {
	*x = SubjectAlternativeName{}
	mi := &file_sigstore_common_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SubjectAlternativeName) ProtoMessage() {}

func (x *SubjectAlternativeName) ProtoReflect() protoreflect.Message {
	mi := &file_sigstore_common_proto_msgTypes[10]
	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 SubjectAlternativeName.ProtoReflect.Descriptor instead.
func (*SubjectAlternativeName) Descriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{10}
}

func (x *SubjectAlternativeName) GetType() SubjectAlternativeNameType {
	if x != nil {
		return x.Type
	}
	return SubjectAlternativeNameType_SUBJECT_ALTERNATIVE_NAME_TYPE_UNSPECIFIED
}

func (x *SubjectAlternativeName) GetIdentity() isSubjectAlternativeName_Identity {
	if x != nil {
		return x.Identity
	}
	return nil
}

func (x *SubjectAlternativeName) GetRegexp() string {
	if x != nil {
		if x, ok := x.Identity.(*SubjectAlternativeName_Regexp); ok {
			return x.Regexp
		}
	}
	return ""
}

func (x *SubjectAlternativeName) GetValue() string {
	if x != nil {
		if x, ok := x.Identity.(*SubjectAlternativeName_Value); ok {
			return x.Value
		}
	}
	return ""
}

type isSubjectAlternativeName_Identity interface {
	isSubjectAlternativeName_Identity()
}

type SubjectAlternativeName_Regexp struct {
	// A regular expression describing the expected value for
	// the SAN.
	Regexp string `protobuf:"bytes,2,opt,name=regexp,proto3,oneof"`
}

type SubjectAlternativeName_Value struct {
	// The exact value to match against.
	Value string `protobuf:"bytes,3,opt,name=value,proto3,oneof"`
}

func (*SubjectAlternativeName_Regexp) isSubjectAlternativeName_Identity() {}

func (*SubjectAlternativeName_Value) isSubjectAlternativeName_Identity() {}

// A collection of X.509 certificates.
//
// This "chain" can be used in multiple contexts, such as providing a root CA
// certificate within a TUF root of trust or multiple untrusted certificates for
// the purpose of chain building.
type X509CertificateChain struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// One or more DER-encoded certificates.
	//
	// In some contexts (such as `VerificationMaterial.x509_certificate_chain`), this sequence
	// has an imposed order. Unless explicitly specified, there is otherwise no
	// guaranteed order.
	Certificates  []*X509Certificate `protobuf:"bytes,1,rep,name=certificates,proto3" json:"certificates,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *X509CertificateChain) Reset() {
	*x = X509CertificateChain{}
	mi := &file_sigstore_common_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*X509CertificateChain) ProtoMessage() {}

func (x *X509CertificateChain) ProtoReflect() protoreflect.Message {
	mi := &file_sigstore_common_proto_msgTypes[11]
	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 X509CertificateChain.ProtoReflect.Descriptor instead.
func (*X509CertificateChain) Descriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{11}
}

func (x *X509CertificateChain) GetCertificates() []*X509Certificate {
	if x != nil {
		return x.Certificates
	}
	return nil
}

// The time range is closed and includes both the start and end times,
// (i.e., [start, end]).
// End is optional to be able to capture a period that has started but
// has no known end.
type TimeRange struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Start         *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=start,proto3" json:"start,omitempty"`
	End           *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=end,proto3,oneof" json:"end,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TimeRange) Reset() {
	*x = TimeRange{}
	mi := &file_sigstore_common_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*TimeRange) ProtoMessage() {}

func (x *TimeRange) ProtoReflect() protoreflect.Message {
	mi := &file_sigstore_common_proto_msgTypes[12]
	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 TimeRange.ProtoReflect.Descriptor instead.
func (*TimeRange) Descriptor() ([]byte, []int) {
	return file_sigstore_common_proto_rawDescGZIP(), []int{12}
}

func (x *TimeRange) GetStart() *timestamppb.Timestamp {
	if x != nil {
		return x.Start
	}
	return nil
}

func (x *TimeRange) GetEnd() *timestamppb.Timestamp {
	if x != nil {
		return x.End
	}
	return nil
}

var File_sigstore_common_proto protoreflect.FileDescriptor

const file_sigstore_common_proto_rawDesc = "" +
	"\n" +
	"\x15sigstore_common.proto\x12\x16dev.sigstore.common.v1\x1a\x1fgoogle/api/field_behavior.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"i\n" +
	"\n" +
	"HashOutput\x12C\n" +
	"\talgorithm\x18\x01 \x01(\x0e2%.dev.sigstore.common.v1.HashAlgorithmR\talgorithm\x12\x16\n" +
	"\x06digest\x18\x02 \x01(\fR\x06digest\"\x80\x01\n" +
	"\x10MessageSignature\x12I\n" +
	"\x0emessage_digest\x18\x01 \x01(\v2\".dev.sigstore.common.v1.HashOutputR\rmessageDigest\x12!\n" +
	"\tsignature\x18\x02 \x01(\fB\x03\xe0A\x02R\tsignature\"#\n" +
	"\x05LogId\x12\x1a\n" +
	"\x06key_id\x18\x01 \x01(\fB\x03\xe0A\x02R\x05keyId\"H\n" +
	"\x16RFC3161SignedTimestamp\x12.\n" +
	"\x10signed_timestamp\x18\x01 \x01(\fB\x03\xe0A\x02R\x0fsignedTimestamp\"\xd9\x01\n" +
	"\tPublicKey\x12 \n" +
	"\traw_bytes\x18\x01 \x01(\fH\x00R\brawBytes\x88\x01\x01\x12I\n" +
	"\vkey_details\x18\x02 \x01(\x0e2(.dev.sigstore.common.v1.PublicKeyDetailsR\n" +
	"keyDetails\x12C\n" +
	"\tvalid_for\x18\x03 \x01(\v2!.dev.sigstore.common.v1.TimeRangeH\x01R\bvalidFor\x88\x01\x01B\f\n" +
	"\n" +
	"_raw_bytesB\f\n" +
	"\n" +
	"_valid_for\")\n" +
	"\x13PublicKeyIdentifier\x12\x12\n" +
	"\x04hint\x18\x01 \x01(\tR\x04hint\"'\n" +
	"\x10ObjectIdentifier\x12\x13\n" +
	"\x02id\x18\x01 \x03(\x05B\x03\xe0A\x02R\x02id\"m\n" +
	"\x19ObjectIdentifierValuePair\x12:\n" +
	"\x03oid\x18\x01 \x01(\v2(.dev.sigstore.common.v1.ObjectIdentifierR\x03oid\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value\"X\n" +
	"\x11DistinguishedName\x12\"\n" +
	"\forganization\x18\x01 \x01(\tR\forganization\x12\x1f\n" +
	"\vcommon_name\x18\x02 \x01(\tR\n" +
	"commonName\"3\n" +
	"\x0fX509Certificate\x12 \n" +
	"\traw_bytes\x18\x01 \x01(\fB\x03\xe0A\x02R\brawBytes\"\x9e\x01\n" +
	"\x16SubjectAlternativeName\x12F\n" +
	"\x04type\x18\x01 \x01(\x0e22.dev.sigstore.common.v1.SubjectAlternativeNameTypeR\x04type\x12\x18\n" +
	"\x06regexp\x18\x02 \x01(\tH\x00R\x06regexp\x12\x16\n" +
	"\x05value\x18\x03 \x01(\tH\x00R\x05valueB\n" +
	"\n" +
	"\bidentity\"c\n" +
	"\x14X509CertificateChain\x12K\n" +
	"\fcertificates\x18\x01 \x03(\v2'.dev.sigstore.common.v1.X509CertificateR\fcertificates\"x\n" +
	"\tTimeRange\x120\n" +
	"\x05start\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x05start\x121\n" +
	"\x03end\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampH\x00R\x03end\x88\x01\x01B\x06\n" +
	"\x04_end*}\n" +
	"\rHashAlgorithm\x12\x1e\n" +
	"\x1aHASH_ALGORITHM_UNSPECIFIED\x10\x00\x12\f\n" +
	"\bSHA2_256\x10\x01\x12\f\n" +
	"\bSHA2_384\x10\x02\x12\f\n" +
	"\bSHA2_512\x10\x03\x12\x10\n" +
	"\bSHA3_256\x10\x04\x1a\x02\b\x01\x12\x10\n" +
	"\bSHA3_384\x10\x05\x1a\x02\b\x01*\x9e\x05\n" +
	"\x10PublicKeyDetails\x12\"\n" +
	"\x1ePUBLIC_KEY_DETAILS_UNSPECIFIED\x10\x00\x12\x19\n" +
	"\x11PKCS1_RSA_PKCS1V5\x10\x01\x1a\x02\b\x01\x12\x15\n" +
	"\rPKCS1_RSA_PSS\x10\x02\x1a\x02\b\x01\x12\x18\n" +
	"\x10PKIX_RSA_PKCS1V5\x10\x03\x1a\x02\b\x01\x12\x14\n" +
	"\fPKIX_RSA_PSS\x10\x04\x1a\x02\b\x01\x12!\n" +
	"\x1dPKIX_RSA_PKCS1V15_2048_SHA256\x10\t\x12!\n" +
	"\x1dPKIX_RSA_PKCS1V15_3072_SHA256\x10\n" +
	"\x12!\n" +
	"\x1dPKIX_RSA_PKCS1V15_4096_SHA256\x10\v\x12\x1c\n" +
	"\x18PKIX_RSA_PSS_2048_SHA256\x10\x10\x12\x1c\n" +
	"\x18PKIX_RSA_PSS_3072_SHA256\x10\x11\x12\x1c\n" +
	"\x18PKIX_RSA_PSS_4096_SHA256\x10\x12\x12$\n" +
	"\x1cPKIX_ECDSA_P256_HMAC_SHA_256\x10\x06\x1a\x02\b\x01\x12\x1b\n" +
	"\x17PKIX_ECDSA_P256_SHA_256\x10\x05\x12\x1b\n" +
	"\x17PKIX_ECDSA_P384_SHA_384\x10\f\x12\x1b\n" +
	"\x17PKIX_ECDSA_P521_SHA_512\x10\r\x12\x10\n" +
	"\fPKIX_ED25519\x10\a\x12\x13\n" +
	"\x0fPKIX_ED25519_PH\x10\b\x12\x1f\n" +
	"\x17PKIX_ECDSA_P384_SHA_256\x10\x13\x1a\x02\b\x01\x12\x1f\n" +
	"\x17PKIX_ECDSA_P521_SHA_256\x10\x14\x1a\x02\b\x01\x12\x12\n" +
	"\n" +
	"LMS_SHA256\x10\x0e\x1a\x02\b\x01\x12\x14\n" +
	"\fLMOTS_SHA256\x10\x0f\x1a\x02\b\x01\x12\r\n" +
	"\tML_DSA_44\x10\x17\x12\r\n" +
	"\tML_DSA_65\x10\x15\x12\r\n" +
	"\tML_DSA_87\x10\x16\"\x04\b\x18\x102*o\n" +
	"\x1aSubjectAlternativeNameType\x12-\n" +
	")SUBJECT_ALTERNATIVE_NAME_TYPE_UNSPECIFIED\x10\x00\x12\t\n" +
	"\x05EMAIL\x10\x01\x12\a\n" +
	"\x03URI\x10\x02\x12\x0e\n" +
	"\n" +
	"OTHER_NAME\x10\x03B|\n" +
	"\x1cdev.sigstore.proto.common.v1B\vCommonProtoP\x01Z6github.com/sigstore/protobuf-specs/gen/pb-go/common/v1\xea\x02\x14Sigstore::Common::V1b\x06proto3"

var (
	file_sigstore_common_proto_rawDescOnce sync.Once
	file_sigstore_common_proto_rawDescData []byte
)

func file_sigstore_common_proto_rawDescGZIP() []byte {
	file_sigstore_common_proto_rawDescOnce.Do(func() {
		file_sigstore_common_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_sigstore_common_proto_rawDesc), len(file_sigstore_common_proto_rawDesc)))
	})
	return file_sigstore_common_proto_rawDescData
}

var file_sigstore_common_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_sigstore_common_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
var file_sigstore_common_proto_goTypes = []any{
	(HashAlgorithm)(0),                // 0: dev.sigstore.common.v1.HashAlgorithm
	(PublicKeyDetails)(0),             // 1: dev.sigstore.common.v1.PublicKeyDetails
	(SubjectAlternativeNameType)(0),   // 2: dev.sigstore.common.v1.SubjectAlternativeNameType
	(*HashOutput)(nil),                // 3: dev.sigstore.common.v1.HashOutput
	(*MessageSignature)(nil),          // 4: dev.sigstore.common.v1.MessageSignature
	(*LogId)(nil),                     // 5: dev.sigstore.common.v1.LogId
	(*RFC3161SignedTimestamp)(nil),    // 6: dev.sigstore.common.v1.RFC3161SignedTimestamp
	(*PublicKey)(nil),                 // 7: dev.sigstore.common.v1.PublicKey
	(*PublicKeyIdentifier)(nil),       // 8: dev.sigstore.common.v1.PublicKeyIdentifier
	(*ObjectIdentifier)(nil),          // 9: dev.sigstore.common.v1.ObjectIdentifier
	(*ObjectIdentifierValuePair)(nil), // 10: dev.sigstore.common.v1.ObjectIdentifierValuePair
	(*DistinguishedName)(nil),         // 11: dev.sigstore.common.v1.DistinguishedName
	(*X509Certificate)(nil),           // 12: dev.sigstore.common.v1.X509Certificate
	(*SubjectAlternativeName)(nil),    // 13: dev.sigstore.common.v1.SubjectAlternativeName
	(*X509CertificateChain)(nil),      // 14: dev.sigstore.common.v1.X509CertificateChain
	(*TimeRange)(nil),                 // 15: dev.sigstore.common.v1.TimeRange
	(*timestamppb.Timestamp)(nil),     // 16: google.protobuf.Timestamp
}
var file_sigstore_common_proto_depIdxs = []int32{
	0,  // 0: dev.sigstore.common.v1.HashOutput.algorithm:type_name -> dev.sigstore.common.v1.HashAlgorithm
	3,  // 1: dev.sigstore.common.v1.MessageSignature.message_digest:type_name -> dev.sigstore.common.v1.HashOutput
	1,  // 2: dev.sigstore.common.v1.PublicKey.key_details:type_name -> dev.sigstore.common.v1.PublicKeyDetails
	15, // 3: dev.sigstore.common.v1.PublicKey.valid_for:type_name -> dev.sigstore.common.v1.TimeRange
	9,  // 4: dev.sigstore.common.v1.ObjectIdentifierValuePair.oid:type_name -> dev.sigstore.common.v1.ObjectIdentifier
	2,  // 5: dev.sigstore.common.v1.SubjectAlternativeName.type:type_name -> dev.sigstore.common.v1.SubjectAlternativeNameType
	12, // 6: dev.sigstore.common.v1.X509CertificateChain.certificates:type_name -> dev.sigstore.common.v1.X509Certificate
	16, // 7: dev.sigstore.common.v1.TimeRange.start:type_name -> google.protobuf.Timestamp
	16, // 8: dev.sigstore.common.v1.TimeRange.end:type_name -> google.protobuf.Timestamp
	9,  // [9:9] is the sub-list for method output_type
	9,  // [9:9] is the sub-list for method input_type
	9,  // [9:9] is the sub-list for extension type_name
	9,  // [9:9] is the sub-list for extension extendee
	0,  // [0:9] is the sub-list for field type_name
}

func init() { file_sigstore_common_proto_init() }
func file_sigstore_common_proto_init() {
	if File_sigstore_common_proto != nil {
		return
	}
	file_sigstore_common_proto_msgTypes[4].OneofWrappers = []any{}
	file_sigstore_common_proto_msgTypes[10].OneofWrappers = []any{
		(*SubjectAlternativeName_Regexp)(nil),
		(*SubjectAlternativeName_Value)(nil),
	}
	file_sigstore_common_proto_msgTypes[12].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_sigstore_common_proto_rawDesc), len(file_sigstore_common_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   13,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_sigstore_common_proto_goTypes,
		DependencyIndexes: file_sigstore_common_proto_depIdxs,
		EnumInfos:         file_sigstore_common_proto_enumTypes,
		MessageInfos:      file_sigstore_common_proto_msgTypes,
	}.Build()
	File_sigstore_common_proto = out.File
	file_sigstore_common_proto_goTypes = nil
	file_sigstore_common_proto_depIdxs = nil
}
