// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.3
// 	protoc        v6.31.1
// source: transport.proto

// Set of messages used to interact with the registry canister.
//
// The registry canister implements the following three methods:
//
// get_latest_version(RegistryGetLatestVersionRequest) ->
// RegistryGetLatestVersionResponse
//
// get_value(RegistryGetValueRequest) -> RegistryGetValueResponse
//
// atomic_mutate(RegistryAtomicMutateRequest) -> RegistryAtomicMutateResponse
//
// get_latest_version() returns the latest version of the registry, i.e. the
// version of the last update made to the registry.
//
// get_value() returns the a value for specified version of a specified key from
// the registry, or the latest version if a version was not specified.
// get_value() returns a RegistryError if the key was not present.
//
// atomic_mutate() inserts, updates or deletes a set of keys in the registry.
// Mutations are atomic, meaning either all mutations are applied, or none
// are applied.
//
// Note that registry versions are always strictly >= 0, a -1 value is used
// to signal that no version was assigned.

package v1

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	reflect "reflect"
	sync "sync"
)

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)
)

// Enum value maps for RegistryError_Code.
var (
	RegistryError_Code_name = map[int32]string{
		0:   "MALFORMED_MESSAGE",
		1:   "KEY_NOT_PRESENT",
		2:   "KEY_ALREADY_PRESENT",
		3:   "VERSION_NOT_LATEST",
		4:   "VERSION_BEYOND_LATEST",
		999: "INTERNAL_ERROR",
	}
	RegistryError_Code_value = map[string]int32{
		"MALFORMED_MESSAGE":     0,
		"KEY_NOT_PRESENT":       1,
		"KEY_ALREADY_PRESENT":   2,
		"VERSION_NOT_LATEST":    3,
		"VERSION_BEYOND_LATEST": 4,
		"INTERNAL_ERROR":        999,
	}
)

// Enum value maps for RegistryMutation_Type.
var (
	RegistryMutation_Type_name = map[int32]string{
		0: "INSERT",
		1: "UPDATE",
		2: "DELETE",
		4: "UPSERT",
	}
	RegistryMutation_Type_value = map[string]int32{
		"INSERT": 0,
		"UPDATE": 1,
		"DELETE": 2,
		"UPSERT": 4,
	}
)

var (
	file_transport_proto_rawDescOnce sync.Once
	file_transport_proto_rawDescData = file_transport_proto_rawDesc
)

var File_transport_proto protoreflect.FileDescriptor

var file_transport_proto_depIdxs = []int32{
	0,  // 0: ic_registry_transport.pb.v1.RegistryError.code:type_name -> ic_registry_transport.pb.v1.RegistryError.Code
	3,  // 1: ic_registry_transport.pb.v1.RegistryDelta.values:type_name -> ic_registry_transport.pb.v1.RegistryValue
	2,  // 2: ic_registry_transport.pb.v1.RegistryGetChangesSinceResponse.error:type_name -> ic_registry_transport.pb.v1.RegistryError
	4,  // 3: ic_registry_transport.pb.v1.RegistryGetChangesSinceResponse.deltas:type_name -> ic_registry_transport.pb.v1.RegistryDelta
	18, // 4: ic_registry_transport.pb.v1.RegistryGetValueRequest.version:type_name -> google.protobuf.UInt64Value
	2,  // 5: ic_registry_transport.pb.v1.RegistryGetValueResponse.error:type_name -> ic_registry_transport.pb.v1.RegistryError
	1,  // 6: ic_registry_transport.pb.v1.RegistryMutation.mutation_type:type_name -> ic_registry_transport.pb.v1.RegistryMutation.Type
	10, // 7: ic_registry_transport.pb.v1.RegistryAtomicMutateRequest.mutations:type_name -> ic_registry_transport.pb.v1.RegistryMutation
	11, // 8: ic_registry_transport.pb.v1.RegistryAtomicMutateRequest.preconditions:type_name -> ic_registry_transport.pb.v1.Precondition
	2,  // 9: ic_registry_transport.pb.v1.RegistryAtomicMutateResponse.errors:type_name -> ic_registry_transport.pb.v1.RegistryError
	19, // 10: ic_registry_transport.pb.v1.MixedHashTree.empty:type_name -> google.protobuf.Empty
	16, // 11: ic_registry_transport.pb.v1.MixedHashTree.fork:type_name -> ic_registry_transport.pb.v1.MixedHashTree.Fork
	17, // 12: ic_registry_transport.pb.v1.MixedHashTree.labeled:type_name -> ic_registry_transport.pb.v1.MixedHashTree.Labeled
	14, // 13: ic_registry_transport.pb.v1.CertifiedResponse.hash_tree:type_name -> ic_registry_transport.pb.v1.MixedHashTree
	14, // 14: ic_registry_transport.pb.v1.MixedHashTree.Fork.left_tree:type_name -> ic_registry_transport.pb.v1.MixedHashTree
	14, // 15: ic_registry_transport.pb.v1.MixedHashTree.Fork.right_tree:type_name -> ic_registry_transport.pb.v1.MixedHashTree
	14, // 16: ic_registry_transport.pb.v1.MixedHashTree.Labeled.subtree:type_name -> ic_registry_transport.pb.v1.MixedHashTree
	17, // [17:17] is the sub-list for method output_type
	17, // [17:17] is the sub-list for method input_type
	17, // [17:17] is the sub-list for extension type_name
	17, // [17:17] is the sub-list for extension extendee
	0,  // [0:17] is the sub-list for field type_name
}

var file_transport_proto_enumTypes = make([]protoimpl.EnumInfo, 2)

var file_transport_proto_goTypes = []any{
	(RegistryError_Code)(0),                  // 0: ic_registry_transport.pb.v1.RegistryError.Code
	(RegistryMutation_Type)(0),               // 1: ic_registry_transport.pb.v1.RegistryMutation.Type
	(*RegistryError)(nil),                    // 2: ic_registry_transport.pb.v1.RegistryError
	(*RegistryValue)(nil),                    // 3: ic_registry_transport.pb.v1.RegistryValue
	(*RegistryDelta)(nil),                    // 4: ic_registry_transport.pb.v1.RegistryDelta
	(*RegistryGetChangesSinceRequest)(nil),   // 5: ic_registry_transport.pb.v1.RegistryGetChangesSinceRequest
	(*RegistryGetChangesSinceResponse)(nil),  // 6: ic_registry_transport.pb.v1.RegistryGetChangesSinceResponse
	(*RegistryGetValueRequest)(nil),          // 7: ic_registry_transport.pb.v1.RegistryGetValueRequest
	(*RegistryGetValueResponse)(nil),         // 8: ic_registry_transport.pb.v1.RegistryGetValueResponse
	(*RegistryGetLatestVersionResponse)(nil), // 9: ic_registry_transport.pb.v1.RegistryGetLatestVersionResponse
	(*RegistryMutation)(nil),                 // 10: ic_registry_transport.pb.v1.RegistryMutation
	(*Precondition)(nil),                     // 11: ic_registry_transport.pb.v1.Precondition
	(*RegistryAtomicMutateRequest)(nil),      // 12: ic_registry_transport.pb.v1.RegistryAtomicMutateRequest
	(*RegistryAtomicMutateResponse)(nil),     // 13: ic_registry_transport.pb.v1.RegistryAtomicMutateResponse
	(*MixedHashTree)(nil),                    // 14: ic_registry_transport.pb.v1.MixedHashTree
	(*CertifiedResponse)(nil),                // 15: ic_registry_transport.pb.v1.CertifiedResponse
	(*MixedHashTree_Fork)(nil),               // 16: ic_registry_transport.pb.v1.MixedHashTree.Fork
	(*MixedHashTree_Labeled)(nil),            // 17: ic_registry_transport.pb.v1.MixedHashTree.Labeled
	(*wrapperspb.UInt64Value)(nil),           // 18: google.protobuf.UInt64Value
	(*emptypb.Empty)(nil),                    // 19: google.protobuf.Empty
}

var file_transport_proto_msgTypes = make([]protoimpl.MessageInfo, 16)

var file_transport_proto_rawDesc = []byte{
	0x0a, 0x0f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74,
	0x6f, 0x12, 0x1b, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74,
	0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x1a, 0x1b,
	0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f,
	0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f,
	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61,
	0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x94, 0x02, 0x0a, 0x0d,
	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x43, 0x0a,
	0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2f, 0x2e, 0x69, 0x63,
	0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70,
	0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
	0x72, 0x79, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x2e, 0x43, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x63, 0x6f,
	0x64, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01,
	0x28, 0x09, 0x52, 0x06, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65,
	0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x93, 0x01, 0x0a,
	0x04, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x15, 0x0a, 0x11, 0x4d, 0x41, 0x4c, 0x46, 0x4f, 0x52, 0x4d,
	0x45, 0x44, 0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 0x47, 0x45, 0x10, 0x00, 0x12, 0x13, 0x0a, 0x0f,
	0x4b, 0x45, 0x59, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, 0x54, 0x10,
	0x01, 0x12, 0x17, 0x0a, 0x13, 0x4b, 0x45, 0x59, 0x5f, 0x41, 0x4c, 0x52, 0x45, 0x41, 0x44, 0x59,
	0x5f, 0x50, 0x52, 0x45, 0x53, 0x45, 0x4e, 0x54, 0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x56, 0x45,
	0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x4c, 0x41, 0x54, 0x45, 0x53, 0x54,
	0x10, 0x03, 0x12, 0x19, 0x0a, 0x15, 0x56, 0x45, 0x52, 0x53, 0x49, 0x4f, 0x4e, 0x5f, 0x42, 0x45,
	0x59, 0x4f, 0x4e, 0x44, 0x5f, 0x4c, 0x41, 0x54, 0x45, 0x53, 0x54, 0x10, 0x04, 0x12, 0x13, 0x0a,
	0x0e, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e, 0x41, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10,
	0xe7, 0x07, 0x22, 0x68, 0x0a, 0x0d, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x56, 0x61,
	0x6c, 0x75, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01,
	0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72,
	0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73,
	0x69, 0x6f, 0x6e, 0x12, 0x27, 0x0a, 0x0f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x5f,
	0x6d, 0x61, 0x72, 0x6b, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0e, 0x64, 0x65,
	0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x61, 0x72, 0x6b, 0x65, 0x72, 0x22, 0x65, 0x0a, 0x0d,
	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x12, 0x10, 0x0a,
	0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12,
	0x42, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32,
	0x2a, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72,
	0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65,
	0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x76, 0x61, 0x6c,
	0x75, 0x65, 0x73, 0x22, 0x3a, 0x0a, 0x1e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x47,
	0x65, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x52, 0x65,
	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
	0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22,
	0xc1, 0x01, 0x0a, 0x1f, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x47, 0x65, 0x74, 0x43,
	0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x53, 0x69, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
	0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79,
	0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31,
	0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x52, 0x05,
	0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
	0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12,
	0x42, 0x0a, 0x06, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32,
	0x2a, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72,
	0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x52, 0x65,
	0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x52, 0x06, 0x64, 0x65, 0x6c,
	0x74, 0x61, 0x73, 0x22, 0x63, 0x0a, 0x17, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x47,
	0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x36,
	0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32,
	0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
	0x66, 0x2e, 0x55, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x76,
	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20,
	0x01, 0x28, 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x8c, 0x01, 0x0a, 0x18, 0x52, 0x65, 0x67,
	0x69, 0x73, 0x74, 0x72, 0x79, 0x47, 0x65, 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73,
	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x40, 0x0a, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x18, 0x01,
	0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74,
	0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e,
	0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x45, 0x72, 0x72, 0x6f, 0x72,
	0x52, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69,
	0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f,
	0x6e, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0c,
	0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x3c, 0x0a, 0x20, 0x52, 0x65, 0x67, 0x69, 0x73,
	0x74, 0x72, 0x79, 0x47, 0x65, 0x74, 0x4c, 0x61, 0x74, 0x65, 0x73, 0x74, 0x56, 0x65, 0x72, 0x73,
	0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x76,
	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65,
	0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xcb, 0x01, 0x0a, 0x10, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74,
	0x72, 0x79, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x57, 0x0a, 0x0d, 0x6d, 0x75,
	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28,
	0x0e, 0x32, 0x32, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f,
	0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e,
	0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
	0x2e, 0x54, 0x79, 0x70, 0x65, 0x52, 0x0c, 0x6d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54,
	0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c,
	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03,
	0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x36, 0x0a, 0x04, 0x54,
	0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x49, 0x4e, 0x53, 0x45, 0x52, 0x54, 0x10, 0x00, 0x12,
	0x0a, 0x0a, 0x06, 0x55, 0x50, 0x44, 0x41, 0x54, 0x45, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x44,
	0x45, 0x4c, 0x45, 0x54, 0x45, 0x10, 0x02, 0x12, 0x0a, 0x0a, 0x06, 0x55, 0x50, 0x53, 0x45, 0x52,
	0x54, 0x10, 0x04, 0x22, 0x4b, 0x0a, 0x0c, 0x50, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74,
	0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
	0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x29, 0x0a, 0x10, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65,
	0x64, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52,
	0x0f, 0x65, 0x78, 0x70, 0x65, 0x63, 0x74, 0x65, 0x64, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e,
	0x22, 0xc1, 0x01, 0x0a, 0x1b, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x41, 0x74, 0x6f,
	0x6d, 0x69, 0x63, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
	0x12, 0x4b, 0x0a, 0x09, 0x6d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x01, 0x20,
	0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72,
	0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76,
	0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x69,
	0x6f, 0x6e, 0x52, 0x09, 0x6d, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x4f, 0x0a,
	0x0d, 0x70, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x05,
	0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74,
	0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e,
	0x76, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52,
	0x0d, 0x70, 0x72, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x4a, 0x04,
	0x08, 0x04, 0x10, 0x05, 0x22, 0x7c, 0x0a, 0x1c, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79,
	0x41, 0x74, 0x6f, 0x6d, 0x69, 0x63, 0x4d, 0x75, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70,
	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x42, 0x0a, 0x06, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x18, 0x01,
	0x20, 0x03, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74,
	0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e,
	0x76, 0x31, 0x2e, 0x52, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x45, 0x72, 0x72, 0x6f, 0x72,
	0x52, 0x06, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73,
	0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69,
	0x6f, 0x6e, 0x22, 0xad, 0x04, 0x0a, 0x0d, 0x4d, 0x69, 0x78, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68,
	0x54, 0x72, 0x65, 0x65, 0x12, 0x2e, 0x0a, 0x05, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x01, 0x20,
	0x01, 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f,
	0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x48, 0x00, 0x52, 0x05, 0x65,
	0x6d, 0x70, 0x74, 0x79, 0x12, 0x45, 0x0a, 0x04, 0x66, 0x6f, 0x72, 0x6b, 0x18, 0x02, 0x20, 0x01,
	0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79,
	0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31,
	0x2e, 0x4d, 0x69, 0x78, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x54, 0x72, 0x65, 0x65, 0x2e, 0x46,
	0x6f, 0x72, 0x6b, 0x48, 0x00, 0x52, 0x04, 0x66, 0x6f, 0x72, 0x6b, 0x12, 0x4e, 0x0a, 0x07, 0x6c,
	0x61, 0x62, 0x65, 0x6c, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x69,
	0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73,
	0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x78, 0x65, 0x64,
	0x48, 0x61, 0x73, 0x68, 0x54, 0x72, 0x65, 0x65, 0x2e, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x65, 0x64,
	0x48, 0x00, 0x52, 0x07, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x09, 0x6c,
	0x65, 0x61, 0x66, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00,
	0x52, 0x08, 0x6c, 0x65, 0x61, 0x66, 0x44, 0x61, 0x74, 0x61, 0x12, 0x25, 0x0a, 0x0d, 0x70, 0x72,
	0x75, 0x6e, 0x65, 0x64, 0x5f, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28,
	0x0c, 0x48, 0x00, 0x52, 0x0c, 0x70, 0x72, 0x75, 0x6e, 0x65, 0x64, 0x44, 0x69, 0x67, 0x65, 0x73,
	0x74, 0x1a, 0x9a, 0x01, 0x0a, 0x04, 0x46, 0x6f, 0x72, 0x6b, 0x12, 0x47, 0x0a, 0x09, 0x6c, 0x65,
	0x66, 0x74, 0x5f, 0x74, 0x72, 0x65, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e,
	0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e,
	0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x78, 0x65,
	0x64, 0x48, 0x61, 0x73, 0x68, 0x54, 0x72, 0x65, 0x65, 0x52, 0x08, 0x6c, 0x65, 0x66, 0x74, 0x54,
	0x72, 0x65, 0x65, 0x12, 0x49, 0x0a, 0x0a, 0x72, 0x69, 0x67, 0x68, 0x74, 0x5f, 0x74, 0x72, 0x65,
	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67,
	0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e,
	0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x78, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x54,
	0x72, 0x65, 0x65, 0x52, 0x09, 0x72, 0x69, 0x67, 0x68, 0x74, 0x54, 0x72, 0x65, 0x65, 0x1a, 0x65,
	0x0a, 0x07, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x65, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62,
	0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12,
	0x44, 0x0a, 0x07, 0x73, 0x75, 0x62, 0x74, 0x72, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b,
	0x32, 0x2a, 0x2e, 0x69, 0x63, 0x5f, 0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74,
	0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f, 0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x4d,
	0x69, 0x78, 0x65, 0x64, 0x48, 0x61, 0x73, 0x68, 0x54, 0x72, 0x65, 0x65, 0x52, 0x07, 0x73, 0x75,
	0x62, 0x74, 0x72, 0x65, 0x65, 0x42, 0x0b, 0x0a, 0x09, 0x74, 0x72, 0x65, 0x65, 0x5f, 0x65, 0x6e,
	0x75, 0x6d, 0x22, 0x7e, 0x0a, 0x11, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x65, 0x64, 0x52,
	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x47, 0x0a, 0x09, 0x68, 0x61, 0x73, 0x68, 0x5f,
	0x74, 0x72, 0x65, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x69, 0x63, 0x5f,
	0x72, 0x65, 0x67, 0x69, 0x73, 0x74, 0x72, 0x79, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x70, 0x6f,
	0x72, 0x74, 0x2e, 0x70, 0x62, 0x2e, 0x76, 0x31, 0x2e, 0x4d, 0x69, 0x78, 0x65, 0x64, 0x48, 0x61,
	0x73, 0x68, 0x54, 0x72, 0x65, 0x65, 0x52, 0x08, 0x68, 0x61, 0x73, 0x68, 0x54, 0x72, 0x65, 0x65,
	0x12, 0x20, 0x0a, 0x0b, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x65, 0x18,
	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0b, 0x63, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61,
	0x74, 0x65, 0x42, 0x0a, 0x5a, 0x08, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x76, 0x31, 0x62, 0x06,
	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
}

func file_transport_proto_rawDescGZIP() []byte {
	file_transport_proto_rawDescOnce.Do(func() {
		file_transport_proto_rawDescData = protoimpl.X.CompressGZIP(file_transport_proto_rawDescData)
	})
	return file_transport_proto_rawDescData
}

// Message encoding a response to any *_certified method call.
type CertifiedResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The hash tree encoding both the response and the intermediate
	// nodes required to recompute the root hash stored in
	// "certified_data" of the canister.
	//
	// Note that the contents of the tree depends on the type of request
	// issued.
	HashTree *MixedHashTree `protobuf:"bytes,1,opt,name=hash_tree,json=hashTree,proto3" json:"hash_tree,omitempty"`
	// The certificate obtained from the system using
	// ic0.data_certificate_copy.
	Certificate   []byte `protobuf:"bytes,2,opt,name=certificate,proto3" json:"certificate,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Deprecated: Use CertifiedResponse.ProtoReflect.Descriptor instead.
func (*CertifiedResponse) Descriptor() ([]byte, []int) {
	return file_transport_proto_rawDescGZIP(), []int{13}
}

func (x *CertifiedResponse) GetCertificate() []byte {
	if x != nil {
		return x.Certificate
	}
	return nil
}

func (x *CertifiedResponse) GetHashTree() *MixedHashTree {
	if x != nil {
		return x.HashTree
	}
	return nil
}

func (*CertifiedResponse) ProtoMessage() {}

func (x *CertifiedResponse) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

type MixedHashTree struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to TreeEnum:
	//
	//	*MixedHashTree_Empty
	//	*MixedHashTree_Fork_
	//	*MixedHashTree_Labeled_
	//	*MixedHashTree_LeafData
	//	*MixedHashTree_PrunedDigest
	TreeEnum      isMixedHashTree_TreeEnum `protobuf_oneof:"tree_enum"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Deprecated: Use MixedHashTree.ProtoReflect.Descriptor instead.
func (*MixedHashTree) Descriptor() ([]byte, []int) {
	return file_transport_proto_rawDescGZIP(), []int{12}
}

func (x *MixedHashTree) GetEmpty() *emptypb.Empty {
	if x != nil {
		if x, ok := x.TreeEnum.(*MixedHashTree_Empty); ok {
			return x.Empty
		}
	}
	return nil
}

func (x *MixedHashTree) GetFork() *MixedHashTree_Fork {
	if x != nil {
		if x, ok := x.TreeEnum.(*MixedHashTree_Fork_); ok {
			return x.Fork
		}
	}
	return nil
}

func (x *MixedHashTree) GetLabeled() *MixedHashTree_Labeled {
	if x != nil {
		if x, ok := x.TreeEnum.(*MixedHashTree_Labeled_); ok {
			return x.Labeled
		}
	}
	return nil
}

func (x *MixedHashTree) GetLeafData() []byte {
	if x != nil {
		if x, ok := x.TreeEnum.(*MixedHashTree_LeafData); ok {
			return x.LeafData
		}
	}
	return nil
}

func (x *MixedHashTree) GetPrunedDigest() []byte {
	if x != nil {
		if x, ok := x.TreeEnum.(*MixedHashTree_PrunedDigest); ok {
			return x.PrunedDigest
		}
	}
	return nil
}

func (x *MixedHashTree) GetTreeEnum() isMixedHashTree_TreeEnum {
	if x != nil {
		return x.TreeEnum
	}
	return nil
}

func (*MixedHashTree) ProtoMessage() {}

func (x *MixedHashTree) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

type MixedHashTree_Empty struct {
	Empty *emptypb.Empty `protobuf:"bytes,1,opt,name=empty,proto3,oneof"`
}

func (*MixedHashTree_Empty) isMixedHashTree_TreeEnum() {}

type MixedHashTree_Fork struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	LeftTree      *MixedHashTree         `protobuf:"bytes,1,opt,name=left_tree,json=leftTree,proto3" json:"left_tree,omitempty"`
	RightTree     *MixedHashTree         `protobuf:"bytes,2,opt,name=right_tree,json=rightTree,proto3" json:"right_tree,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *MixedHashTree_Fork) GetLeftTree() *MixedHashTree {
	if x != nil {
		return x.LeftTree
	}
	return nil
}

func (x *MixedHashTree_Fork) GetRightTree() *MixedHashTree {
	if x != nil {
		return x.RightTree
	}
	return nil
}

func (*MixedHashTree_Fork) ProtoMessage() {}

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

func (x *MixedHashTree_Fork) Reset() {
	*x = MixedHashTree_Fork{}
	mi := &file_transport_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

type MixedHashTree_Fork_ struct {
	Fork *MixedHashTree_Fork `protobuf:"bytes,2,opt,name=fork,proto3,oneof"`
}

func (*MixedHashTree_Fork_) isMixedHashTree_TreeEnum() {}

type MixedHashTree_Labeled struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Label         []byte                 `protobuf:"bytes,1,opt,name=label,proto3" json:"label,omitempty"`
	Subtree       *MixedHashTree         `protobuf:"bytes,2,opt,name=subtree,proto3" json:"subtree,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *MixedHashTree_Labeled) GetLabel() []byte {
	if x != nil {
		return x.Label
	}
	return nil
}

func (x *MixedHashTree_Labeled) GetSubtree() *MixedHashTree {
	if x != nil {
		return x.Subtree
	}
	return nil
}

func (*MixedHashTree_Labeled) ProtoMessage() {}

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

func (x *MixedHashTree_Labeled) Reset() {
	*x = MixedHashTree_Labeled{}
	mi := &file_transport_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

type MixedHashTree_Labeled_ struct {
	Labeled *MixedHashTree_Labeled `protobuf:"bytes,3,opt,name=labeled,proto3,oneof"`
}

func (*MixedHashTree_Labeled_) isMixedHashTree_TreeEnum() {}

type MixedHashTree_LeafData struct {
	LeafData []byte `protobuf:"bytes,4,opt,name=leaf_data,json=leafData,proto3,oneof"`
}

func (*MixedHashTree_LeafData) isMixedHashTree_TreeEnum() {}

type MixedHashTree_PrunedDigest struct {
	PrunedDigest []byte `protobuf:"bytes,5,opt,name=pruned_digest,json=prunedDigest,proto3,oneof"`
}

func (*MixedHashTree_PrunedDigest) isMixedHashTree_TreeEnum() {}

// A precondition on the version at which the value of a given key was
// last mutated.
type Precondition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Key   []byte                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The precondition is satisfied if and only is the version in the
	// RegistryValue for the key is equal to this.
	ExpectedVersion uint64 `protobuf:"varint,2,opt,name=expected_version,json=expectedVersion,proto3" json:"expected_version,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

// Deprecated: Use Precondition.ProtoReflect.Descriptor instead.
func (*Precondition) Descriptor() ([]byte, []int) {
	return file_transport_proto_rawDescGZIP(), []int{9}
}

func (x *Precondition) GetExpectedVersion() uint64 {
	if x != nil {
		return x.ExpectedVersion
	}
	return 0
}

func (x *Precondition) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

func (*Precondition) ProtoMessage() {}

func (x *Precondition) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// Message corresponding to a list of mutations to apply, atomically, to the
// registry canister. If any of the mutations fails, the whole operation will fail.
type RegistryAtomicMutateRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The set of mutations to apply to the registry.
	Mutations []*RegistryMutation `protobuf:"bytes,1,rep,name=mutations,proto3" json:"mutations,omitempty"`
	// Preconditions at the key level.
	Preconditions []*Precondition `protobuf:"bytes,5,rep,name=preconditions,proto3" json:"preconditions,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Deprecated: Use RegistryAtomicMutateRequest.ProtoReflect.Descriptor instead.
func (*RegistryAtomicMutateRequest) Descriptor() ([]byte, []int) {
	return file_transport_proto_rawDescGZIP(), []int{10}
}

func (x *RegistryAtomicMutateRequest) GetMutations() []*RegistryMutation {
	if x != nil {
		return x.Mutations
	}
	return nil
}

func (x *RegistryAtomicMutateRequest) GetPreconditions() []*Precondition {
	if x != nil {
		return x.Preconditions
	}
	return nil
}

func (*RegistryAtomicMutateRequest) ProtoMessage() {}

func (x *RegistryAtomicMutateRequest) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// Message corresponding to the response of an atomic_mutate request. If any of
// mutations failed the corresponding errors will be reflected in 'errors'.
// Otherwise 'version' will contain the version under which all the mutations
// were applied.
type RegistryAtomicMutateResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If anything went wrong, the registry canister
	// will set this error.
	Errors []*RegistryError `protobuf:"bytes,1,rep,name=errors,proto3" json:"errors,omitempty"`
	// The last version of the registry.
	Version       uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Deprecated: Use RegistryAtomicMutateResponse.ProtoReflect.Descriptor instead.
func (*RegistryAtomicMutateResponse) Descriptor() ([]byte, []int) {
	return file_transport_proto_rawDescGZIP(), []int{11}
}

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

func (x *RegistryAtomicMutateResponse) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (*RegistryAtomicMutateResponse) ProtoMessage() {}

func (x *RegistryAtomicMutateResponse) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// A sequence of changes made to a key in the registry.
type RegistryDelta struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Key           []byte                 `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Values        []*RegistryValue       `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *RegistryDelta) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *RegistryDelta) GetValues() []*RegistryValue {
	if x != nil {
		return x.Values
	}
	return nil
}

func (*RegistryDelta) ProtoMessage() {}

func (x *RegistryDelta) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// Message corresponding to an error while performing
// an operation on the registry.
type RegistryError struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	Code  RegistryError_Code     `protobuf:"varint,1,opt,name=code,proto3,enum=ic_registry_transport.pb.v1.RegistryError_Code" json:"code,omitempty"`
	// The reason for the error.
	// This is optional.
	Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	// The key on which the error occurred.
	// This is optional and only present for by-key errors.
	Key           []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *RegistryError) GetCode() RegistryError_Code {
	if x != nil {
		return x.Code
	}
	return RegistryError_MALFORMED_MESSAGE
}

func (x *RegistryError) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

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

func (*RegistryError) ProtoMessage() {}

func (x *RegistryError) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

type RegistryError_Code int32

const (
	// The message had a problem like a missing field
	// or a field that was set when it shouldn't.
	RegistryError_MALFORMED_MESSAGE RegistryError_Code = 0
	// The 'key' specified on the request was not present
	// in the registry.
	RegistryError_KEY_NOT_PRESENT RegistryError_Code = 1
	// The 'key' specified on the request was already present.
	RegistryError_KEY_ALREADY_PRESENT RegistryError_Code = 2
	// The 'version' specified in a precondition for a mutation
	// was not the latest version.
	RegistryError_VERSION_NOT_LATEST RegistryError_Code = 3
	// The 'version' specified in a precondition for a mutation
	// is beyond the latest version in the registry.
	RegistryError_VERSION_BEYOND_LATEST RegistryError_Code = 4
	// A generic internal error occurred in the registry.
	RegistryError_INTERNAL_ERROR RegistryError_Code = 999
)

func (RegistryError_Code) Descriptor() protoreflect.EnumDescriptor {
	return file_transport_proto_enumTypes[0].Descriptor()
}

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

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

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

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

func (RegistryError_Code) Type() protoreflect.EnumType {
	return &file_transport_proto_enumTypes[0]
}

// Message to retrieve all the changes from the registry
// since 'version'.
type RegistryGetChangesSinceRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Version       uint64                 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *RegistryGetChangesSinceRequest) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (*RegistryGetChangesSinceRequest) ProtoMessage() {}

func (x *RegistryGetChangesSinceRequest) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// Message corresponding to the response from the registry
// canister to a get_latest_version() request.
type RegistryGetChangesSinceResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If anything went wrong, the registry canister
	// will set this error.
	Error *RegistryError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// The last version of the registry.
	Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	// A list of all the keys and all the values that change
	// and all the intermediate changes since the version
	// requested.
	Deltas        []*RegistryDelta `protobuf:"bytes,3,rep,name=deltas,proto3" json:"deltas,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *RegistryGetChangesSinceResponse) GetDeltas() []*RegistryDelta {
	if x != nil {
		return x.Deltas
	}
	return nil
}

func (x *RegistryGetChangesSinceResponse) GetError() *RegistryError {
	if x != nil {
		return x.Error
	}
	return nil
}

func (x *RegistryGetChangesSinceResponse) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (*RegistryGetChangesSinceResponse) ProtoMessage() {}

func (x *RegistryGetChangesSinceResponse) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// Message corresponding to the response from the canister
// to a get_latest_version() request.
type RegistryGetLatestVersionResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// the latest registry version
	Version       uint64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *RegistryGetLatestVersionResponse) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (*RegistryGetLatestVersionResponse) ProtoMessage() {}

func (x *RegistryGetLatestVersionResponse) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// Message to retrieve a version of some registry key
// from the registry canister.
type RegistryGetValueRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The version of the registry key to retrieve.
	// Optional: If not set (or set to the default value, 0), the method
	// will return the last version.
	Version *wrapperspb.UInt64Value `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
	// The byte array corresponding to the key to retrieve
	// from the registry.
	// Required.
	Key           []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *RegistryGetValueRequest) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *RegistryGetValueRequest) GetVersion() *wrapperspb.UInt64Value {
	if x != nil {
		return x.Version
	}
	return nil
}

func (*RegistryGetValueRequest) ProtoMessage() {}

func (x *RegistryGetValueRequest) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// Message corresponding to the response from the canister
// to a get_value() request.
//
// Both 'version' and 'value' are mandatorily set if 'error'
// is not set.
type RegistryGetValueResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If anything went wrong, the registry canister
	// will set this error.
	Error *RegistryError `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
	// the version at which the value corresponding to the queried
	// key was last mutated (inserted, updated, or deleted)
	// before at or at the version specified
	// in the RegistryGetValueRequest.
	Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	// The value retrieved from the registry.
	Value         []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

func (x *RegistryGetValueResponse) GetError() *RegistryError {
	if x != nil {
		return x.Error
	}
	return nil
}

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

func (x *RegistryGetValueResponse) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (*RegistryGetValueResponse) ProtoMessage() {}

func (x *RegistryGetValueResponse) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

// A single mutation in the registry.
type RegistryMutation struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The type of the mutation to apply to the registry.
	// Always required.
	MutationType RegistryMutation_Type `protobuf:"varint,1,opt,name=mutation_type,json=mutationType,proto3,enum=ic_registry_transport.pb.v1.RegistryMutation_Type" json:"mutation_type,omitempty"`
	// The key of the entry to mutate in the registry.
	// Always required.
	Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	// The value to mutate in the registry.
	// Required for insert, update, but not for delete.
	Value         []byte `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Deprecated: Use RegistryMutation.ProtoReflect.Descriptor instead.
func (*RegistryMutation) Descriptor() ([]byte, []int) {
	return file_transport_proto_rawDescGZIP(), []int{8}
}

func (x *RegistryMutation) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

func (x *RegistryMutation) GetMutationType() RegistryMutation_Type {
	if x != nil {
		return x.MutationType
	}
	return RegistryMutation_INSERT
}

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

func (*RegistryMutation) ProtoMessage() {}

func (x *RegistryMutation) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}

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

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

type RegistryMutation_Type int32

const (
	// Key is expected to not exist in the registry at the current version.
	// (This includes the case of a key that has existed in the past and
	// later got deleted).
	// The mutation will fail otherwise.
	RegistryMutation_INSERT RegistryMutation_Type = 0
	// Key is expected to exist in the registry at the current version.
	// The mutation will fail otherwise.
	RegistryMutation_UPDATE RegistryMutation_Type = 1
	// Key is expected to exist in the registry at the current version.
	// The mutation will fail otherwise.
	RegistryMutation_DELETE RegistryMutation_Type = 2
	// If the key does not exist at the current version, it will be created.
	// Otherwise, the value will be updated. The name is common in the
	// database world, and means Update or Insert.
	RegistryMutation_UPSERT RegistryMutation_Type = 4
)

func (RegistryMutation_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_transport_proto_enumTypes[1].Descriptor()
}

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

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

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

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

func (RegistryMutation_Type) Type() protoreflect.EnumType {
	return &file_transport_proto_enumTypes[1]
}

// A single change made to a key in the registry.
type RegistryValue struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The value that was set in this mutation. If the
	// mutation is a deletion, the field has no meaning.
	Value []byte `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// The version at which this mutation happened.
	Version uint64 `protobuf:"varint,2,opt,name=version,proto3" json:"version,omitempty"`
	// If true, this change represents a deletion.
	DeletionMarker bool `protobuf:"varint,3,opt,name=deletion_marker,json=deletionMarker,proto3" json:"deletion_marker,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

func (x *RegistryValue) GetDeletionMarker() bool {
	if x != nil {
		return x.DeletionMarker
	}
	return false
}

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

func (x *RegistryValue) GetVersion() uint64 {
	if x != nil {
		return x.Version
	}
	return 0
}

func (*RegistryValue) ProtoMessage() {}

func (x *RegistryValue) ProtoReflect() protoreflect.Message {
	mi := &file_transport_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)
}
func (x *RegistryValue) Reset() {
	*x = RegistryValue{}
	mi := &file_transport_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}
func (x *RegistryValue) String() string {
	return protoimpl.X.MessageStringOf(x)
}
func init() { file_transport_proto_init() }

func file_transport_proto_init() {
	if File_transport_proto != nil {
		return
	}
	file_transport_proto_msgTypes[12].OneofWrappers = []any{
		(*MixedHashTree_Empty)(nil),
		(*MixedHashTree_Fork_)(nil),
		(*MixedHashTree_Labeled_)(nil),
		(*MixedHashTree_LeafData)(nil),
		(*MixedHashTree_PrunedDigest)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: file_transport_proto_rawDesc,
			NumEnums:      2,
			NumMessages:   16,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_transport_proto_goTypes,
		DependencyIndexes: file_transport_proto_depIdxs,
		EnumInfos:         file_transport_proto_enumTypes,
		MessageInfos:      file_transport_proto_msgTypes,
	}.Build()
	File_transport_proto = out.File
	file_transport_proto_rawDesc = nil
	file_transport_proto_goTypes = nil
	file_transport_proto_depIdxs = nil
}
type isMixedHashTree_TreeEnum interface {
	isMixedHashTree_TreeEnum()
}
