// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.4
// source: mf.proto

package mfer

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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 MFFileOuter_Version int32

const (
	MFFileOuter_VERSION_NONE MFFileOuter_Version = 0
	MFFileOuter_VERSION_ONE  MFFileOuter_Version = 1 // only one for now
)

// Enum value maps for MFFileOuter_Version.
var (
	MFFileOuter_Version_name = map[int32]string{
		0: "VERSION_NONE",
		1: "VERSION_ONE",
	}
	MFFileOuter_Version_value = map[string]int32{
		"VERSION_NONE": 0,
		"VERSION_ONE":  1,
	}
)

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

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

func (MFFileOuter_Version) Descriptor() protoreflect.EnumDescriptor {
	return file_mf_proto_enumTypes[0].Descriptor()
}

func (MFFileOuter_Version) Type() protoreflect.EnumType {
	return &file_mf_proto_enumTypes[0]
}

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

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

type MFFileOuter_CompressionType int32

const (
	MFFileOuter_COMPRESSION_NONE MFFileOuter_CompressionType = 0
	MFFileOuter_COMPRESSION_ZSTD MFFileOuter_CompressionType = 1
)

// Enum value maps for MFFileOuter_CompressionType.
var (
	MFFileOuter_CompressionType_name = map[int32]string{
		0: "COMPRESSION_NONE",
		1: "COMPRESSION_ZSTD",
	}
	MFFileOuter_CompressionType_value = map[string]int32{
		"COMPRESSION_NONE": 0,
		"COMPRESSION_ZSTD": 1,
	}
)

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

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

func (MFFileOuter_CompressionType) Descriptor() protoreflect.EnumDescriptor {
	return file_mf_proto_enumTypes[1].Descriptor()
}

func (MFFileOuter_CompressionType) Type() protoreflect.EnumType {
	return &file_mf_proto_enumTypes[1]
}

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

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

type MFFile_Version int32

const (
	MFFile_VERSION_NONE MFFile_Version = 0
	MFFile_VERSION_ONE  MFFile_Version = 1 // only one for now
)

// Enum value maps for MFFile_Version.
var (
	MFFile_Version_name = map[int32]string{
		0: "VERSION_NONE",
		1: "VERSION_ONE",
	}
	MFFile_Version_value = map[string]int32{
		"VERSION_NONE": 0,
		"VERSION_ONE":  1,
	}
)

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

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

func (MFFile_Version) Descriptor() protoreflect.EnumDescriptor {
	return file_mf_proto_enumTypes[2].Descriptor()
}

func (MFFile_Version) Type() protoreflect.EnumType {
	return &file_mf_proto_enumTypes[2]
}

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

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

type Timestamp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Seconds       int64                  `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"`
	Nanos         int32                  `protobuf:"varint,2,opt,name=nanos,proto3" json:"nanos,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Timestamp) ProtoMessage() {}

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

func (x *Timestamp) GetSeconds() int64 {
	if x != nil {
		return x.Seconds
	}
	return 0
}

func (x *Timestamp) GetNanos() int32 {
	if x != nil {
		return x.Nanos
	}
	return 0
}

type MFFileOuter struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// required mffile root attributes 1xx
	Version         MFFileOuter_Version         `protobuf:"varint,101,opt,name=version,proto3,enum=MFFileOuter_Version" json:"version,omitempty"`
	CompressionType MFFileOuter_CompressionType `protobuf:"varint,102,opt,name=compressionType,proto3,enum=MFFileOuter_CompressionType" json:"compressionType,omitempty"`
	// these are used solely to detect corruption/truncation
	// and not for cryptographic integrity.
	Size   int64  `protobuf:"varint,103,opt,name=size,proto3" json:"size,omitempty"`
	Sha256 []byte `protobuf:"bytes,104,opt,name=sha256,proto3" json:"sha256,omitempty"`
	// uuid must match the uuid in the inner message
	Uuid         []byte `protobuf:"bytes,105,opt,name=uuid,proto3" json:"uuid,omitempty"`
	InnerMessage []byte `protobuf:"bytes,199,opt,name=innerMessage,proto3" json:"innerMessage,omitempty"`
	// detached signature, ascii or binary
	Signature []byte `protobuf:"bytes,201,opt,name=signature,proto3,oneof" json:"signature,omitempty"`
	// full GPG key id
	Signer []byte `protobuf:"bytes,202,opt,name=signer,proto3,oneof" json:"signer,omitempty"`
	// full GPG signing public key, ascii or binary
	SigningPubKey []byte `protobuf:"bytes,203,opt,name=signingPubKey,proto3,oneof" json:"signingPubKey,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MFFileOuter) ProtoMessage() {}

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

func (x *MFFileOuter) GetVersion() MFFileOuter_Version {
	if x != nil {
		return x.Version
	}
	return MFFileOuter_VERSION_NONE
}

func (x *MFFileOuter) GetCompressionType() MFFileOuter_CompressionType {
	if x != nil {
		return x.CompressionType
	}
	return MFFileOuter_COMPRESSION_NONE
}

func (x *MFFileOuter) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *MFFileOuter) GetSha256() []byte {
	if x != nil {
		return x.Sha256
	}
	return nil
}

func (x *MFFileOuter) GetUuid() []byte {
	if x != nil {
		return x.Uuid
	}
	return nil
}

func (x *MFFileOuter) GetInnerMessage() []byte {
	if x != nil {
		return x.InnerMessage
	}
	return nil
}

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

func (x *MFFileOuter) GetSigner() []byte {
	if x != nil {
		return x.Signer
	}
	return nil
}

func (x *MFFileOuter) GetSigningPubKey() []byte {
	if x != nil {
		return x.SigningPubKey
	}
	return nil
}

type MFFilePath struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// required attributes:
	// Path invariants: must be valid UTF-8, use forward slashes only,
	// be relative (no leading /), contain no ".." segments, and no
	// empty segments (no "//").
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	Size int64  `protobuf:"varint,2,opt,name=size,proto3" json:"size,omitempty"`
	// gotta have at least one:
	Hashes []*MFFileChecksum `protobuf:"bytes,3,rep,name=hashes,proto3" json:"hashes,omitempty"`
	// optional per-file metadata
	MimeType      *string    `protobuf:"bytes,301,opt,name=mimeType,proto3,oneof" json:"mimeType,omitempty"`
	Mtime         *Timestamp `protobuf:"bytes,302,opt,name=mtime,proto3,oneof" json:"mtime,omitempty"`
	Ctime         *Timestamp `protobuf:"bytes,303,opt,name=ctime,proto3,oneof" json:"ctime,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MFFilePath) ProtoMessage() {}

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

func (x *MFFilePath) GetPath() string {
	if x != nil {
		return x.Path
	}
	return ""
}

func (x *MFFilePath) GetSize() int64 {
	if x != nil {
		return x.Size
	}
	return 0
}

func (x *MFFilePath) GetHashes() []*MFFileChecksum {
	if x != nil {
		return x.Hashes
	}
	return nil
}

func (x *MFFilePath) GetMimeType() string {
	if x != nil && x.MimeType != nil {
		return *x.MimeType
	}
	return ""
}

func (x *MFFilePath) GetMtime() *Timestamp {
	if x != nil {
		return x.Mtime
	}
	return nil
}

func (x *MFFilePath) GetCtime() *Timestamp {
	if x != nil {
		return x.Ctime
	}
	return nil
}

type MFFileChecksum struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// 1.0 golang implementation must write a multihash here
	// it's ok to only ever use/verify sha256 multihash
	MultiHash     []byte `protobuf:"bytes,1,opt,name=multiHash,proto3" json:"multiHash,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MFFileChecksum) ProtoMessage() {}

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

func (x *MFFileChecksum) GetMultiHash() []byte {
	if x != nil {
		return x.MultiHash
	}
	return nil
}

type MFFile struct {
	state   protoimpl.MessageState `protogen:"open.v1"`
	Version MFFile_Version         `protobuf:"varint,100,opt,name=version,proto3,enum=MFFile_Version" json:"version,omitempty"`
	// required manifest attributes:
	Files []*MFFilePath `protobuf:"bytes,101,rep,name=files,proto3" json:"files,omitempty"`
	// uuid is a random v4 UUID generated when creating the manifest
	// used as part of the signature to prevent replay attacks
	Uuid []byte `protobuf:"bytes,102,opt,name=uuid,proto3" json:"uuid,omitempty"`
	// optional manifest attributes 2xx:
	CreatedAt     *Timestamp `protobuf:"bytes,201,opt,name=createdAt,proto3,oneof" json:"createdAt,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MFFile) ProtoMessage() {}

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

func (x *MFFile) GetVersion() MFFile_Version {
	if x != nil {
		return x.Version
	}
	return MFFile_VERSION_NONE
}

func (x *MFFile) GetFiles() []*MFFilePath {
	if x != nil {
		return x.Files
	}
	return nil
}

func (x *MFFile) GetUuid() []byte {
	if x != nil {
		return x.Uuid
	}
	return nil
}

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

var File_mf_proto protoreflect.FileDescriptor

const file_mf_proto_rawDesc = "" +
	"\n" +
	"\bmf.proto\";\n" +
	"\tTimestamp\x12\x18\n" +
	"\aseconds\x18\x01 \x01(\x03R\aseconds\x12\x14\n" +
	"\x05nanos\x18\x02 \x01(\x05R\x05nanos\"\xf0\x03\n" +
	"\vMFFileOuter\x12.\n" +
	"\aversion\x18e \x01(\x0e2\x14.MFFileOuter.VersionR\aversion\x12F\n" +
	"\x0fcompressionType\x18f \x01(\x0e2\x1c.MFFileOuter.CompressionTypeR\x0fcompressionType\x12\x12\n" +
	"\x04size\x18g \x01(\x03R\x04size\x12\x16\n" +
	"\x06sha256\x18h \x01(\fR\x06sha256\x12\x12\n" +
	"\x04uuid\x18i \x01(\fR\x04uuid\x12#\n" +
	"\finnerMessage\x18\xc7\x01 \x01(\fR\finnerMessage\x12\"\n" +
	"\tsignature\x18\xc9\x01 \x01(\fH\x00R\tsignature\x88\x01\x01\x12\x1c\n" +
	"\x06signer\x18\xca\x01 \x01(\fH\x01R\x06signer\x88\x01\x01\x12*\n" +
	"\rsigningPubKey\x18\xcb\x01 \x01(\fH\x02R\rsigningPubKey\x88\x01\x01\",\n" +
	"\aVersion\x12\x10\n" +
	"\fVERSION_NONE\x10\x00\x12\x0f\n" +
	"\vVERSION_ONE\x10\x01\"=\n" +
	"\x0fCompressionType\x12\x14\n" +
	"\x10COMPRESSION_NONE\x10\x00\x12\x14\n" +
	"\x10COMPRESSION_ZSTD\x10\x01B\f\n" +
	"\n" +
	"_signatureB\t\n" +
	"\a_signerB\x10\n" +
	"\x0e_signingPubKey\"\xf0\x01\n" +
	"\n" +
	"MFFilePath\x12\x12\n" +
	"\x04path\x18\x01 \x01(\tR\x04path\x12\x12\n" +
	"\x04size\x18\x02 \x01(\x03R\x04size\x12'\n" +
	"\x06hashes\x18\x03 \x03(\v2\x0f.MFFileChecksumR\x06hashes\x12 \n" +
	"\bmimeType\x18\xad\x02 \x01(\tH\x00R\bmimeType\x88\x01\x01\x12&\n" +
	"\x05mtime\x18\xae\x02 \x01(\v2\n" +
	".TimestampH\x01R\x05mtime\x88\x01\x01\x12&\n" +
	"\x05ctime\x18\xaf\x02 \x01(\v2\n" +
	".TimestampH\x02R\x05ctime\x88\x01\x01B\v\n" +
	"\t_mimeTypeB\b\n" +
	"\x06_mtimeB\b\n" +
	"\x06_ctime\".\n" +
	"\x0eMFFileChecksum\x12\x1c\n" +
	"\tmultiHash\x18\x01 \x01(\fR\tmultiHash\"\xd6\x01\n" +
	"\x06MFFile\x12)\n" +
	"\aversion\x18d \x01(\x0e2\x0f.MFFile.VersionR\aversion\x12!\n" +
	"\x05files\x18e \x03(\v2\v.MFFilePathR\x05files\x12\x12\n" +
	"\x04uuid\x18f \x01(\fR\x04uuid\x12.\n" +
	"\tcreatedAt\x18\xc9\x01 \x01(\v2\n" +
	".TimestampH\x00R\tcreatedAt\x88\x01\x01\",\n" +
	"\aVersion\x12\x10\n" +
	"\fVERSION_NONE\x10\x00\x12\x0f\n" +
	"\vVERSION_ONE\x10\x01B\f\n" +
	"\n" +
	"_createdAtB\x1dZ\x1bgit.eeqj.de/sneak/mfer/mferb\x06proto3"

var (
	file_mf_proto_rawDescOnce sync.Once
	file_mf_proto_rawDescData []byte
)

func file_mf_proto_rawDescGZIP() []byte {
	file_mf_proto_rawDescOnce.Do(func() {
		file_mf_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_mf_proto_rawDesc), len(file_mf_proto_rawDesc)))
	})
	return file_mf_proto_rawDescData
}

var file_mf_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_mf_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
var file_mf_proto_goTypes = []any{
	(MFFileOuter_Version)(0),         // 0: MFFileOuter.Version
	(MFFileOuter_CompressionType)(0), // 1: MFFileOuter.CompressionType
	(MFFile_Version)(0),              // 2: MFFile.Version
	(*Timestamp)(nil),                // 3: Timestamp
	(*MFFileOuter)(nil),              // 4: MFFileOuter
	(*MFFilePath)(nil),               // 5: MFFilePath
	(*MFFileChecksum)(nil),           // 6: MFFileChecksum
	(*MFFile)(nil),                   // 7: MFFile
}
var file_mf_proto_depIdxs = []int32{
	0, // 0: MFFileOuter.version:type_name -> MFFileOuter.Version
	1, // 1: MFFileOuter.compressionType:type_name -> MFFileOuter.CompressionType
	6, // 2: MFFilePath.hashes:type_name -> MFFileChecksum
	3, // 3: MFFilePath.mtime:type_name -> Timestamp
	3, // 4: MFFilePath.ctime:type_name -> Timestamp
	2, // 5: MFFile.version:type_name -> MFFile.Version
	5, // 6: MFFile.files:type_name -> MFFilePath
	3, // 7: MFFile.createdAt:type_name -> Timestamp
	8, // [8:8] is the sub-list for method output_type
	8, // [8:8] is the sub-list for method input_type
	8, // [8:8] is the sub-list for extension type_name
	8, // [8:8] is the sub-list for extension extendee
	0, // [0:8] is the sub-list for field type_name
}

func init() { file_mf_proto_init() }
func file_mf_proto_init() {
	if File_mf_proto != nil {
		return
	}
	file_mf_proto_msgTypes[1].OneofWrappers = []any{}
	file_mf_proto_msgTypes[2].OneofWrappers = []any{}
	file_mf_proto_msgTypes[4].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_mf_proto_rawDesc), len(file_mf_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   5,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_mf_proto_goTypes,
		DependencyIndexes: file_mf_proto_depIdxs,
		EnumInfos:         file_mf_proto_enumTypes,
		MessageInfos:      file_mf_proto_msgTypes,
	}.Build()
	File_mf_proto = out.File
	file_mf_proto_goTypes = nil
	file_mf_proto_depIdxs = nil
}