// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.10
// 	protoc        v6.31.1
// source: bonanza.build/pkg/proto/model/filesystem/filesystem.proto

package filesystem

import (
	core "bonanza.build/pkg/proto/model/core"
	encoding "bonanza.build/pkg/proto/model/encoding"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	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 Leaves struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Files         []*FileNode            `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
	Symlinks      []*SymlinkNode         `protobuf:"bytes,2,rep,name=symlinks,proto3" json:"symlinks,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Leaves) ProtoMessage() {}

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

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

func (x *Leaves) GetSymlinks() []*SymlinkNode {
	if x != nil {
		return x.Symlinks
	}
	return nil
}

type LeavesReference struct {
	state                          protoimpl.MessageState   `protogen:"open.v1"`
	Reference                      *core.DecodableReference `protobuf:"bytes,1,opt,name=reference,proto3" json:"reference,omitempty"`
	MaximumSymlinkEscapementLevels *wrapperspb.UInt32Value  `protobuf:"bytes,2,opt,name=maximum_symlink_escapement_levels,json=maximumSymlinkEscapementLevels,proto3" json:"maximum_symlink_escapement_levels,omitempty"`
	unknownFields                  protoimpl.UnknownFields
	sizeCache                      protoimpl.SizeCache
}

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

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

func (*LeavesReference) ProtoMessage() {}

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

func (x *LeavesReference) GetReference() *core.DecodableReference {
	if x != nil {
		return x.Reference
	}
	return nil
}

func (x *LeavesReference) GetMaximumSymlinkEscapementLevels() *wrapperspb.UInt32Value {
	if x != nil {
		return x.MaximumSymlinkEscapementLevels
	}
	return nil
}

type FileProperties struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Contents      *FileContents          `protobuf:"bytes,1,opt,name=contents,proto3" json:"contents,omitempty"`
	IsExecutable  bool                   `protobuf:"varint,2,opt,name=is_executable,json=isExecutable,proto3" json:"is_executable,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FileProperties) ProtoMessage() {}

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

func (x *FileProperties) GetContents() *FileContents {
	if x != nil {
		return x.Contents
	}
	return nil
}

func (x *FileProperties) GetIsExecutable() bool {
	if x != nil {
		return x.IsExecutable
	}
	return false
}

type FileNode struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Properties    *FileProperties        `protobuf:"bytes,2,opt,name=properties,proto3" json:"properties,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*FileNode) ProtoMessage() {}

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

func (x *FileNode) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *FileNode) GetProperties() *FileProperties {
	if x != nil {
		return x.Properties
	}
	return nil
}

type SymlinkNode struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Target        string                 `protobuf:"bytes,2,opt,name=target,proto3" json:"target,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SymlinkNode) ProtoMessage() {}

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

func (x *SymlinkNode) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *SymlinkNode) GetTarget() string {
	if x != nil {
		return x.Target
	}
	return ""
}

type DirectoryContents struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Leaves:
	//
	//	*DirectoryContents_LeavesExternal
	//	*DirectoryContents_LeavesInline
	Leaves        isDirectoryContents_Leaves `protobuf_oneof:"leaves"`
	Directories   []*DirectoryNode           `protobuf:"bytes,3,rep,name=directories,proto3" json:"directories,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DirectoryContents) ProtoMessage() {}

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

func (x *DirectoryContents) GetLeaves() isDirectoryContents_Leaves {
	if x != nil {
		return x.Leaves
	}
	return nil
}

func (x *DirectoryContents) GetLeavesExternal() *LeavesReference {
	if x != nil {
		if x, ok := x.Leaves.(*DirectoryContents_LeavesExternal); ok {
			return x.LeavesExternal
		}
	}
	return nil
}

func (x *DirectoryContents) GetLeavesInline() *Leaves {
	if x != nil {
		if x, ok := x.Leaves.(*DirectoryContents_LeavesInline); ok {
			return x.LeavesInline
		}
	}
	return nil
}

func (x *DirectoryContents) GetDirectories() []*DirectoryNode {
	if x != nil {
		return x.Directories
	}
	return nil
}

type isDirectoryContents_Leaves interface {
	isDirectoryContents_Leaves()
}

type DirectoryContents_LeavesExternal struct {
	LeavesExternal *LeavesReference `protobuf:"bytes,1,opt,name=leaves_external,json=leavesExternal,proto3,oneof"`
}

type DirectoryContents_LeavesInline struct {
	LeavesInline *Leaves `protobuf:"bytes,2,opt,name=leaves_inline,json=leavesInline,proto3,oneof"`
}

func (*DirectoryContents_LeavesExternal) isDirectoryContents_Leaves() {}

func (*DirectoryContents_LeavesInline) isDirectoryContents_Leaves() {}

type Directory struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Contents:
	//
	//	*Directory_ContentsExternal
	//	*Directory_ContentsInline
	Contents      isDirectory_Contents `protobuf_oneof:"contents"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Directory) ProtoMessage() {}

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

func (x *Directory) GetContents() isDirectory_Contents {
	if x != nil {
		return x.Contents
	}
	return nil
}

func (x *Directory) GetContentsExternal() *DirectoryReference {
	if x != nil {
		if x, ok := x.Contents.(*Directory_ContentsExternal); ok {
			return x.ContentsExternal
		}
	}
	return nil
}

func (x *Directory) GetContentsInline() *DirectoryContents {
	if x != nil {
		if x, ok := x.Contents.(*Directory_ContentsInline); ok {
			return x.ContentsInline
		}
	}
	return nil
}

type isDirectory_Contents interface {
	isDirectory_Contents()
}

type Directory_ContentsExternal struct {
	ContentsExternal *DirectoryReference `protobuf:"bytes,1,opt,name=contents_external,json=contentsExternal,proto3,oneof"`
}

type Directory_ContentsInline struct {
	ContentsInline *DirectoryContents `protobuf:"bytes,2,opt,name=contents_inline,json=contentsInline,proto3,oneof"`
}

func (*Directory_ContentsExternal) isDirectory_Contents() {}

func (*Directory_ContentsInline) isDirectory_Contents() {}

type DirectoryNode struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Name          string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Directory     *Directory             `protobuf:"bytes,2,opt,name=directory,proto3" json:"directory,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DirectoryNode) ProtoMessage() {}

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

func (x *DirectoryNode) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *DirectoryNode) GetDirectory() *Directory {
	if x != nil {
		return x.Directory
	}
	return nil
}

type DirectoryReference struct {
	state                          protoimpl.MessageState   `protogen:"open.v1"`
	Reference                      *core.DecodableReference `protobuf:"bytes,1,opt,name=reference,proto3" json:"reference,omitempty"`
	DirectoriesCount               uint32                   `protobuf:"varint,2,opt,name=directories_count,json=directoriesCount,proto3" json:"directories_count,omitempty"`
	MaximumSymlinkEscapementLevels *wrapperspb.UInt32Value  `protobuf:"bytes,3,opt,name=maximum_symlink_escapement_levels,json=maximumSymlinkEscapementLevels,proto3" json:"maximum_symlink_escapement_levels,omitempty"`
	unknownFields                  protoimpl.UnknownFields
	sizeCache                      protoimpl.SizeCache
}

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

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

func (*DirectoryReference) ProtoMessage() {}

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

func (x *DirectoryReference) GetReference() *core.DecodableReference {
	if x != nil {
		return x.Reference
	}
	return nil
}

func (x *DirectoryReference) GetDirectoriesCount() uint32 {
	if x != nil {
		return x.DirectoriesCount
	}
	return 0
}

func (x *DirectoryReference) GetMaximumSymlinkEscapementLevels() *wrapperspb.UInt32Value {
	if x != nil {
		return x.MaximumSymlinkEscapementLevels
	}
	return nil
}

type FileContents struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Level:
	//
	//	*FileContents_FileContentsListReference
	//	*FileContents_ChunkReference
	Level          isFileContents_Level `protobuf_oneof:"level"`
	TotalSizeBytes uint64               `protobuf:"varint,3,opt,name=total_size_bytes,json=totalSizeBytes,proto3" json:"total_size_bytes,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*FileContents) ProtoMessage() {}

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

func (x *FileContents) GetLevel() isFileContents_Level {
	if x != nil {
		return x.Level
	}
	return nil
}

func (x *FileContents) GetFileContentsListReference() *core.DecodableReference {
	if x != nil {
		if x, ok := x.Level.(*FileContents_FileContentsListReference); ok {
			return x.FileContentsListReference
		}
	}
	return nil
}

func (x *FileContents) GetChunkReference() *core.DecodableReference {
	if x != nil {
		if x, ok := x.Level.(*FileContents_ChunkReference); ok {
			return x.ChunkReference
		}
	}
	return nil
}

func (x *FileContents) GetTotalSizeBytes() uint64 {
	if x != nil {
		return x.TotalSizeBytes
	}
	return 0
}

type isFileContents_Level interface {
	isFileContents_Level()
}

type FileContents_FileContentsListReference struct {
	FileContentsListReference *core.DecodableReference `protobuf:"bytes,1,opt,name=file_contents_list_reference,json=fileContentsListReference,proto3,oneof"`
}

type FileContents_ChunkReference struct {
	ChunkReference *core.DecodableReference `protobuf:"bytes,2,opt,name=chunk_reference,json=chunkReference,proto3,oneof"`
}

func (*FileContents_FileContentsListReference) isFileContents_Level() {}

func (*FileContents_ChunkReference) isFileContents_Level() {}

type DirectoryAccessParameters struct {
	state         protoimpl.MessageState    `protogen:"open.v1"`
	Encoders      []*encoding.BinaryEncoder `protobuf:"bytes,1,rep,name=encoders,proto3" json:"encoders,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*DirectoryAccessParameters) ProtoMessage() {}

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

func (x *DirectoryAccessParameters) GetEncoders() []*encoding.BinaryEncoder {
	if x != nil {
		return x.Encoders
	}
	return nil
}

type DirectoryCreationParameters struct {
	state                     protoimpl.MessageState     `protogen:"open.v1"`
	Access                    *DirectoryAccessParameters `protobuf:"bytes,1,opt,name=access,proto3" json:"access,omitempty"`
	DirectoryMaximumSizeBytes uint32                     `protobuf:"varint,2,opt,name=directory_maximum_size_bytes,json=directoryMaximumSizeBytes,proto3" json:"directory_maximum_size_bytes,omitempty"`
	unknownFields             protoimpl.UnknownFields
	sizeCache                 protoimpl.SizeCache
}

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

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

func (*DirectoryCreationParameters) ProtoMessage() {}

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

func (x *DirectoryCreationParameters) GetAccess() *DirectoryAccessParameters {
	if x != nil {
		return x.Access
	}
	return nil
}

func (x *DirectoryCreationParameters) GetDirectoryMaximumSizeBytes() uint32 {
	if x != nil {
		return x.DirectoryMaximumSizeBytes
	}
	return 0
}

type FileAccessParameters struct {
	state                    protoimpl.MessageState    `protogen:"open.v1"`
	ChunkEncoders            []*encoding.BinaryEncoder `protobuf:"bytes,1,rep,name=chunk_encoders,json=chunkEncoders,proto3" json:"chunk_encoders,omitempty"`
	FileContentsListEncoders []*encoding.BinaryEncoder `protobuf:"bytes,2,rep,name=file_contents_list_encoders,json=fileContentsListEncoders,proto3" json:"file_contents_list_encoders,omitempty"`
	unknownFields            protoimpl.UnknownFields
	sizeCache                protoimpl.SizeCache
}

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

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

func (*FileAccessParameters) ProtoMessage() {}

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

func (x *FileAccessParameters) GetChunkEncoders() []*encoding.BinaryEncoder {
	if x != nil {
		return x.ChunkEncoders
	}
	return nil
}

func (x *FileAccessParameters) GetFileContentsListEncoders() []*encoding.BinaryEncoder {
	if x != nil {
		return x.FileContentsListEncoders
	}
	return nil
}

type FileCreationParameters struct {
	state                            protoimpl.MessageState `protogen:"open.v1"`
	Access                           *FileAccessParameters  `protobuf:"bytes,1,opt,name=access,proto3" json:"access,omitempty"`
	ChunkMinimumSizeBytes            uint32                 `protobuf:"varint,2,opt,name=chunk_minimum_size_bytes,json=chunkMinimumSizeBytes,proto3" json:"chunk_minimum_size_bytes,omitempty"`
	ChunkMaximumSizeBytes            uint32                 `protobuf:"varint,3,opt,name=chunk_maximum_size_bytes,json=chunkMaximumSizeBytes,proto3" json:"chunk_maximum_size_bytes,omitempty"`
	FileContentsListMinimumSizeBytes uint32                 `protobuf:"varint,4,opt,name=file_contents_list_minimum_size_bytes,json=fileContentsListMinimumSizeBytes,proto3" json:"file_contents_list_minimum_size_bytes,omitempty"`
	FileContentsListMaximumSizeBytes uint32                 `protobuf:"varint,5,opt,name=file_contents_list_maximum_size_bytes,json=fileContentsListMaximumSizeBytes,proto3" json:"file_contents_list_maximum_size_bytes,omitempty"`
	unknownFields                    protoimpl.UnknownFields
	sizeCache                        protoimpl.SizeCache
}

func (x *FileCreationParameters) Reset() {
	*x = FileCreationParameters{}
	mi := &file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*FileCreationParameters) ProtoMessage() {}

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

func (x *FileCreationParameters) GetAccess() *FileAccessParameters {
	if x != nil {
		return x.Access
	}
	return nil
}

func (x *FileCreationParameters) GetChunkMinimumSizeBytes() uint32 {
	if x != nil {
		return x.ChunkMinimumSizeBytes
	}
	return 0
}

func (x *FileCreationParameters) GetChunkMaximumSizeBytes() uint32 {
	if x != nil {
		return x.ChunkMaximumSizeBytes
	}
	return 0
}

func (x *FileCreationParameters) GetFileContentsListMinimumSizeBytes() uint32 {
	if x != nil {
		return x.FileContentsListMinimumSizeBytes
	}
	return 0
}

func (x *FileCreationParameters) GetFileContentsListMaximumSizeBytes() uint32 {
	if x != nil {
		return x.FileContentsListMaximumSizeBytes
	}
	return 0
}

var File_bonanza_build_pkg_proto_model_filesystem_filesystem_proto protoreflect.FileDescriptor

const file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDesc = "" +
	"\n" +
	"9bonanza.build/pkg/proto/model/filesystem/filesystem.proto\x12\x18bonanza.model.filesystem\x1a-bonanza.build/pkg/proto/model/core/core.proto\x1a5bonanza.build/pkg/proto/model/encoding/encoding.proto\x1a\x1egoogle/protobuf/wrappers.proto\"\x85\x01\n" +
	"\x06Leaves\x128\n" +
	"\x05files\x18\x01 \x03(\v2\".bonanza.model.filesystem.FileNodeR\x05files\x12A\n" +
	"\bsymlinks\x18\x02 \x03(\v2%.bonanza.model.filesystem.SymlinkNodeR\bsymlinks\"\xe7\x01\n" +
	"\x0fLeavesReference\x12k\n" +
	"\treference\x18\x01 \x01(\v2&.bonanza.model.core.DecodableReferenceB%\xea\xd7 !\x12\x1fbonanza.model.filesystem.LeavesR\treference\x12g\n" +
	"!maximum_symlink_escapement_levels\x18\x02 \x01(\v2\x1c.google.protobuf.UInt32ValueR\x1emaximumSymlinkEscapementLevels\"y\n" +
	"\x0eFileProperties\x12B\n" +
	"\bcontents\x18\x01 \x01(\v2&.bonanza.model.filesystem.FileContentsR\bcontents\x12#\n" +
	"\ris_executable\x18\x02 \x01(\bR\fisExecutable\"h\n" +
	"\bFileNode\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12H\n" +
	"\n" +
	"properties\x18\x02 \x01(\v2(.bonanza.model.filesystem.FilePropertiesR\n" +
	"properties\"9\n" +
	"\vSymlinkNode\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
	"\x06target\x18\x02 \x01(\tR\x06target\"\x87\x02\n" +
	"\x11DirectoryContents\x12T\n" +
	"\x0fleaves_external\x18\x01 \x01(\v2).bonanza.model.filesystem.LeavesReferenceH\x00R\x0eleavesExternal\x12G\n" +
	"\rleaves_inline\x18\x02 \x01(\v2 .bonanza.model.filesystem.LeavesH\x00R\fleavesInline\x12I\n" +
	"\vdirectories\x18\x03 \x03(\v2'.bonanza.model.filesystem.DirectoryNodeR\vdirectoriesB\b\n" +
	"\x06leaves\"\xcc\x01\n" +
	"\tDirectory\x12[\n" +
	"\x11contents_external\x18\x01 \x01(\v2,.bonanza.model.filesystem.DirectoryReferenceH\x00R\x10contentsExternal\x12V\n" +
	"\x0fcontents_inline\x18\x02 \x01(\v2+.bonanza.model.filesystem.DirectoryContentsH\x00R\x0econtentsInlineB\n" +
	"\n" +
	"\bcontents\"f\n" +
	"\rDirectoryNode\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12A\n" +
	"\tdirectory\x18\x02 \x01(\v2#.bonanza.model.filesystem.DirectoryR\tdirectory\"\xa2\x02\n" +
	"\x12DirectoryReference\x12v\n" +
	"\treference\x18\x01 \x01(\v2&.bonanza.model.core.DecodableReferenceB0\xea\xd7 ,\x12*bonanza.model.filesystem.DirectoryContentsR\treference\x12+\n" +
	"\x11directories_count\x18\x02 \x01(\rR\x10directoriesCount\x12g\n" +
	"!maximum_symlink_escapement_levels\x18\x03 \x01(\v2\x1c.google.protobuf.UInt32ValueR\x1emaximumSymlinkEscapementLevels\"\xb5\x02\n" +
	"\fFileContents\x12\x96\x01\n" +
	"\x1cfile_contents_list_reference\x18\x01 \x01(\v2&.bonanza.model.core.DecodableReferenceB+\xea\xd7 '\x1a%bonanza.model.filesystem.FileContentsH\x00R\x19fileContentsListReference\x12Y\n" +
	"\x0fchunk_reference\x18\x02 \x01(\v2&.bonanza.model.core.DecodableReferenceB\x06\xea\xd7 \x02\n" +
	"\x00H\x00R\x0echunkReference\x12(\n" +
	"\x10total_size_bytes\x18\x03 \x01(\x04R\x0etotalSizeBytesB\a\n" +
	"\x05level\"^\n" +
	"\x19DirectoryAccessParameters\x12A\n" +
	"\bencoders\x18\x01 \x03(\v2%.bonanza.model.encoding.BinaryEncoderR\bencoders\"\xab\x01\n" +
	"\x1bDirectoryCreationParameters\x12K\n" +
	"\x06access\x18\x01 \x01(\v23.bonanza.model.filesystem.DirectoryAccessParametersR\x06access\x12?\n" +
	"\x1cdirectory_maximum_size_bytes\x18\x02 \x01(\rR\x19directoryMaximumSizeBytes\"\xca\x01\n" +
	"\x14FileAccessParameters\x12L\n" +
	"\x0echunk_encoders\x18\x01 \x03(\v2%.bonanza.model.encoding.BinaryEncoderR\rchunkEncoders\x12d\n" +
	"\x1bfile_contents_list_encoders\x18\x02 \x03(\v2%.bonanza.model.encoding.BinaryEncoderR\x18fileContentsListEncoders\"\xf4\x02\n" +
	"\x16FileCreationParameters\x12F\n" +
	"\x06access\x18\x01 \x01(\v2..bonanza.model.filesystem.FileAccessParametersR\x06access\x127\n" +
	"\x18chunk_minimum_size_bytes\x18\x02 \x01(\rR\x15chunkMinimumSizeBytes\x127\n" +
	"\x18chunk_maximum_size_bytes\x18\x03 \x01(\rR\x15chunkMaximumSizeBytes\x12O\n" +
	"%file_contents_list_minimum_size_bytes\x18\x04 \x01(\rR fileContentsListMinimumSizeBytes\x12O\n" +
	"%file_contents_list_maximum_size_bytes\x18\x05 \x01(\rR fileContentsListMaximumSizeBytesB*Z(bonanza.build/pkg/proto/model/filesystemb\x06proto3"

var (
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDescOnce sync.Once
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDescData []byte
)

func file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDescGZIP() []byte {
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDescOnce.Do(func() {
		file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDesc), len(file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDesc)))
	})
	return file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDescData
}

var file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_msgTypes = make([]protoimpl.MessageInfo, 14)
var file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_goTypes = []any{
	(*Leaves)(nil),                      // 0: bonanza.model.filesystem.Leaves
	(*LeavesReference)(nil),             // 1: bonanza.model.filesystem.LeavesReference
	(*FileProperties)(nil),              // 2: bonanza.model.filesystem.FileProperties
	(*FileNode)(nil),                    // 3: bonanza.model.filesystem.FileNode
	(*SymlinkNode)(nil),                 // 4: bonanza.model.filesystem.SymlinkNode
	(*DirectoryContents)(nil),           // 5: bonanza.model.filesystem.DirectoryContents
	(*Directory)(nil),                   // 6: bonanza.model.filesystem.Directory
	(*DirectoryNode)(nil),               // 7: bonanza.model.filesystem.DirectoryNode
	(*DirectoryReference)(nil),          // 8: bonanza.model.filesystem.DirectoryReference
	(*FileContents)(nil),                // 9: bonanza.model.filesystem.FileContents
	(*DirectoryAccessParameters)(nil),   // 10: bonanza.model.filesystem.DirectoryAccessParameters
	(*DirectoryCreationParameters)(nil), // 11: bonanza.model.filesystem.DirectoryCreationParameters
	(*FileAccessParameters)(nil),        // 12: bonanza.model.filesystem.FileAccessParameters
	(*FileCreationParameters)(nil),      // 13: bonanza.model.filesystem.FileCreationParameters
	(*core.DecodableReference)(nil),     // 14: bonanza.model.core.DecodableReference
	(*wrapperspb.UInt32Value)(nil),      // 15: google.protobuf.UInt32Value
	(*encoding.BinaryEncoder)(nil),      // 16: bonanza.model.encoding.BinaryEncoder
}
var file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_depIdxs = []int32{
	3,  // 0: bonanza.model.filesystem.Leaves.files:type_name -> bonanza.model.filesystem.FileNode
	4,  // 1: bonanza.model.filesystem.Leaves.symlinks:type_name -> bonanza.model.filesystem.SymlinkNode
	14, // 2: bonanza.model.filesystem.LeavesReference.reference:type_name -> bonanza.model.core.DecodableReference
	15, // 3: bonanza.model.filesystem.LeavesReference.maximum_symlink_escapement_levels:type_name -> google.protobuf.UInt32Value
	9,  // 4: bonanza.model.filesystem.FileProperties.contents:type_name -> bonanza.model.filesystem.FileContents
	2,  // 5: bonanza.model.filesystem.FileNode.properties:type_name -> bonanza.model.filesystem.FileProperties
	1,  // 6: bonanza.model.filesystem.DirectoryContents.leaves_external:type_name -> bonanza.model.filesystem.LeavesReference
	0,  // 7: bonanza.model.filesystem.DirectoryContents.leaves_inline:type_name -> bonanza.model.filesystem.Leaves
	7,  // 8: bonanza.model.filesystem.DirectoryContents.directories:type_name -> bonanza.model.filesystem.DirectoryNode
	8,  // 9: bonanza.model.filesystem.Directory.contents_external:type_name -> bonanza.model.filesystem.DirectoryReference
	5,  // 10: bonanza.model.filesystem.Directory.contents_inline:type_name -> bonanza.model.filesystem.DirectoryContents
	6,  // 11: bonanza.model.filesystem.DirectoryNode.directory:type_name -> bonanza.model.filesystem.Directory
	14, // 12: bonanza.model.filesystem.DirectoryReference.reference:type_name -> bonanza.model.core.DecodableReference
	15, // 13: bonanza.model.filesystem.DirectoryReference.maximum_symlink_escapement_levels:type_name -> google.protobuf.UInt32Value
	14, // 14: bonanza.model.filesystem.FileContents.file_contents_list_reference:type_name -> bonanza.model.core.DecodableReference
	14, // 15: bonanza.model.filesystem.FileContents.chunk_reference:type_name -> bonanza.model.core.DecodableReference
	16, // 16: bonanza.model.filesystem.DirectoryAccessParameters.encoders:type_name -> bonanza.model.encoding.BinaryEncoder
	10, // 17: bonanza.model.filesystem.DirectoryCreationParameters.access:type_name -> bonanza.model.filesystem.DirectoryAccessParameters
	16, // 18: bonanza.model.filesystem.FileAccessParameters.chunk_encoders:type_name -> bonanza.model.encoding.BinaryEncoder
	16, // 19: bonanza.model.filesystem.FileAccessParameters.file_contents_list_encoders:type_name -> bonanza.model.encoding.BinaryEncoder
	12, // 20: bonanza.model.filesystem.FileCreationParameters.access:type_name -> bonanza.model.filesystem.FileAccessParameters
	21, // [21:21] is the sub-list for method output_type
	21, // [21:21] is the sub-list for method input_type
	21, // [21:21] is the sub-list for extension type_name
	21, // [21:21] is the sub-list for extension extendee
	0,  // [0:21] is the sub-list for field type_name
}

func init() { file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_init() }
func file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_init() {
	if File_bonanza_build_pkg_proto_model_filesystem_filesystem_proto != nil {
		return
	}
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_msgTypes[5].OneofWrappers = []any{
		(*DirectoryContents_LeavesExternal)(nil),
		(*DirectoryContents_LeavesInline)(nil),
	}
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_msgTypes[6].OneofWrappers = []any{
		(*Directory_ContentsExternal)(nil),
		(*Directory_ContentsInline)(nil),
	}
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_msgTypes[9].OneofWrappers = []any{
		(*FileContents_FileContentsListReference)(nil),
		(*FileContents_ChunkReference)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDesc), len(file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_rawDesc)),
			NumEnums:      0,
			NumMessages:   14,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_goTypes,
		DependencyIndexes: file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_depIdxs,
		MessageInfos:      file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_msgTypes,
	}.Build()
	File_bonanza_build_pkg_proto_model_filesystem_filesystem_proto = out.File
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_goTypes = nil
	file_bonanza_build_pkg_proto_model_filesystem_filesystem_proto_depIdxs = nil
}
