// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v6.32.1
// source: tls.proto

package microtraffic

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// Signal kind: main or intermediate
type SignalKind int32

const (
	// Main signal
	SignalKind_SIGNAL_MAIN SignalKind = 0
	// Intermediate signal
	SignalKind_SIGNAL_INTERMEDIATE SignalKind = 1
)

// Enum value maps for SignalKind.
var (
	SignalKind_name = map[int32]string{
		0: "SIGNAL_MAIN",
		1: "SIGNAL_INTERMEDIATE",
	}
	SignalKind_value = map[string]int32{
		"SIGNAL_MAIN":         0,
		"SIGNAL_INTERMEDIATE": 1,
	}
)

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

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

func (SignalKind) Descriptor() protoreflect.EnumDescriptor {
	return file_tls_proto_enumTypes[0].Descriptor()
}

func (SignalKind) Type() protoreflect.EnumType {
	return &file_tls_proto_enumTypes[0]
}

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

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

// Traffic light group type
type GroupType int32

const (
	// Unknown type
	GroupType_GROUP_TYPE_UNKNOWN GroupType = 0
	// Vehicle group
	GroupType_GROUP_TYPE_VEHICLE GroupType = 1
	// Pedestrian group
	GroupType_GROUP_TYPE_PEDESTRIAN GroupType = 2
)

// Enum value maps for GroupType.
var (
	GroupType_name = map[int32]string{
		0: "GROUP_TYPE_UNKNOWN",
		1: "GROUP_TYPE_VEHICLE",
		2: "GROUP_TYPE_PEDESTRIAN",
	}
	GroupType_value = map[string]int32{
		"GROUP_TYPE_UNKNOWN":    0,
		"GROUP_TYPE_VEHICLE":    1,
		"GROUP_TYPE_PEDESTRIAN": 2,
	}
)

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

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

func (GroupType) Descriptor() protoreflect.EnumDescriptor {
	return file_tls_proto_enumTypes[1].Descriptor()
}

func (GroupType) Type() protoreflect.EnumType {
	return &file_tls_proto_enumTypes[1]
}

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

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

// Maneuver direction
type MovementDirection int32

const (
	// Unknown direction
	MovementDirection_MOVEMENT_DIRECTION_UNKNOWN MovementDirection = 0
	// Left turn
	MovementDirection_MOVEMENT_DIRECTION_LEFT MovementDirection = 1
	// Straight ahead
	MovementDirection_MOVEMENT_DIRECTION_FORWARD MovementDirection = 2
	// Right turn
	MovementDirection_MOVEMENT_DIRECTION_RIGHT MovementDirection = 3
)

// Enum value maps for MovementDirection.
var (
	MovementDirection_name = map[int32]string{
		0: "MOVEMENT_DIRECTION_UNKNOWN",
		1: "MOVEMENT_DIRECTION_LEFT",
		2: "MOVEMENT_DIRECTION_FORWARD",
		3: "MOVEMENT_DIRECTION_RIGHT",
	}
	MovementDirection_value = map[string]int32{
		"MOVEMENT_DIRECTION_UNKNOWN": 0,
		"MOVEMENT_DIRECTION_LEFT":    1,
		"MOVEMENT_DIRECTION_FORWARD": 2,
		"MOVEMENT_DIRECTION_RIGHT":   3,
	}
)

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

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

func (MovementDirection) Descriptor() protoreflect.EnumDescriptor {
	return file_tls_proto_enumTypes[2].Descriptor()
}

func (MovementDirection) Type() protoreflect.EnumType {
	return &file_tls_proto_enumTypes[2]
}

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

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

// Traffic light definition
type TrafficLight struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Numeric identifier
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Point geometry
	Geom *Point `protobuf:"bytes,2,opt,name=geom,proto3" json:"geom,omitempty"`
	// Set of traffic light groups
	Groups []*Group `protobuf:"bytes,3,rep,name=groups,proto3" json:"groups,omitempty"`
	// Set of time marks for groups
	Times []int64 `protobuf:"varint,4,rep,packed,name=times,proto3" json:"times,omitempty"`
	// Signal kinds for groups
	SignalsKinds  []SignalKind `protobuf:"varint,5,rep,packed,name=signals_kinds,json=signalsKinds,proto3,enum=micro_traffic_sim.SignalKind" json:"signals_kinds,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TrafficLight) ProtoMessage() {}

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

func (x *TrafficLight) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *TrafficLight) GetGeom() *Point {
	if x != nil {
		return x.Geom
	}
	return nil
}

func (x *TrafficLight) GetGroups() []*Group {
	if x != nil {
		return x.Groups
	}
	return nil
}

func (x *TrafficLight) GetTimes() []int64 {
	if x != nil {
		return x.Times
	}
	return nil
}

func (x *TrafficLight) GetSignalsKinds() []SignalKind {
	if x != nil {
		return x.SignalsKinds
	}
	return nil
}

// Traffic light group definition
type Group struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Numeric identifier
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Human-readable label
	Label string `protobuf:"bytes,2,opt,name=label,proto3" json:"label,omitempty"`
	// Collection of point geometry
	Geom []*Point `protobuf:"bytes,3,rep,name=geom,proto3" json:"geom,omitempty"`
	// Collection of cell IDs
	Cells []int64 `protobuf:"varint,4,rep,packed,name=cells,proto3" json:"cells,omitempty"`
	// Collection of signals
	Signals []string `protobuf:"bytes,5,rep,name=signals,proto3" json:"signals,omitempty"`
	// Movement metadata for the signal group
	Movements []*GroupMovementMetadata `protobuf:"bytes,6,rep,name=movements,proto3" json:"movements,omitempty"`
	// Crosswalk length in meters (optional; if set, the group must be pedestrian)
	CrosswalkLength float64 `protobuf:"fixed64,7,opt,name=crosswalk_length,json=crosswalkLength,proto3" json:"crosswalk_length,omitempty"`
	// Group type (vehicle or pedestrian)
	Type          GroupType `protobuf:"varint,8,opt,name=type,proto3,enum=micro_traffic_sim.GroupType" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Group) ProtoMessage() {}

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

func (x *Group) GetId() int64 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *Group) GetLabel() string {
	if x != nil {
		return x.Label
	}
	return ""
}

func (x *Group) GetGeom() []*Point {
	if x != nil {
		return x.Geom
	}
	return nil
}

func (x *Group) GetCells() []int64 {
	if x != nil {
		return x.Cells
	}
	return nil
}

func (x *Group) GetSignals() []string {
	if x != nil {
		return x.Signals
	}
	return nil
}

func (x *Group) GetMovements() []*GroupMovementMetadata {
	if x != nil {
		return x.Movements
	}
	return nil
}

func (x *Group) GetCrosswalkLength() float64 {
	if x != nil {
		return x.CrosswalkLength
	}
	return 0
}

func (x *Group) GetType() GroupType {
	if x != nil {
		return x.Type
	}
	return GroupType_GROUP_TYPE_UNKNOWN
}

// GroupMovementMetadata: statistical info for a traffic light group by movement direction
type GroupMovementMetadata struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Source cell ID (must be part of the group)
	Source int64 `protobuf:"varint,1,opt,name=source,proto3" json:"source,omitempty"`
	// Target cell ID
	Target int64 `protobuf:"varint,2,opt,name=target,proto3" json:"target,omitempty"`
	// Movement direction
	Direction MovementDirection `protobuf:"varint,3,opt,name=direction,proto3,enum=micro_traffic_sim.MovementDirection" json:"direction,omitempty"`
	// True traffic flow (vehicles per hour)
	Flow float64 `protobuf:"fixed64,4,opt,name=flow,proto3" json:"flow,omitempty"`
	// Turn radius for the maneuver geometry (trajectory)
	TurnRadius    float64 `protobuf:"fixed64,5,opt,name=turn_radius,json=turnRadius,proto3" json:"turn_radius,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GroupMovementMetadata) ProtoMessage() {}

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

func (x *GroupMovementMetadata) GetSource() int64 {
	if x != nil {
		return x.Source
	}
	return 0
}

func (x *GroupMovementMetadata) GetTarget() int64 {
	if x != nil {
		return x.Target
	}
	return 0
}

func (x *GroupMovementMetadata) GetDirection() MovementDirection {
	if x != nil {
		return x.Direction
	}
	return MovementDirection_MOVEMENT_DIRECTION_UNKNOWN
}

func (x *GroupMovementMetadata) GetFlow() float64 {
	if x != nil {
		return x.Flow
	}
	return 0
}

func (x *GroupMovementMetadata) GetTurnRadius() float64 {
	if x != nil {
		return x.TurnRadius
	}
	return 0
}

// Traffic lights payload bound to a session
type SessionTLS struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Session identifier (UUIDv4)
	SessionId *UUIDv4 `protobuf:"bytes,1,opt,name=session_id,json=sessionId,proto3" json:"session_id,omitempty"`
	// Traffic light data
	Data          []*TrafficLight `protobuf:"bytes,2,rep,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SessionTLS) ProtoMessage() {}

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

func (x *SessionTLS) GetSessionId() *UUIDv4 {
	if x != nil {
		return x.SessionId
	}
	return nil
}

func (x *SessionTLS) GetData() []*TrafficLight {
	if x != nil {
		return x.Data
	}
	return nil
}

// Server response for traffic light ingest
type SessionTLSResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Response code (0 = OK)
	Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
	// Human-readable message
	Text          string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SessionTLSResponse) ProtoMessage() {}

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

func (x *SessionTLSResponse) GetCode() uint32 {
	if x != nil {
		return x.Code
	}
	return 0
}

func (x *SessionTLSResponse) GetText() string {
	if x != nil {
		return x.Text
	}
	return ""
}

var File_tls_proto protoreflect.FileDescriptor

const file_tls_proto_rawDesc = "" +
	"\n" +
	"\ttls.proto\x12\x11micro_traffic_sim\x1a\n" +
	"uuid.proto\x1a\n" +
	"cell.proto\"\xd8\x01\n" +
	"\fTrafficLight\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x03R\x02id\x12,\n" +
	"\x04geom\x18\x02 \x01(\v2\x18.micro_traffic_sim.PointR\x04geom\x120\n" +
	"\x06groups\x18\x03 \x03(\v2\x18.micro_traffic_sim.GroupR\x06groups\x12\x14\n" +
	"\x05times\x18\x04 \x03(\x03R\x05times\x12B\n" +
	"\rsignals_kinds\x18\x05 \x03(\x0e2\x1d.micro_traffic_sim.SignalKindR\fsignalsKinds\"\xb0\x02\n" +
	"\x05Group\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x03R\x02id\x12\x14\n" +
	"\x05label\x18\x02 \x01(\tR\x05label\x12,\n" +
	"\x04geom\x18\x03 \x03(\v2\x18.micro_traffic_sim.PointR\x04geom\x12\x14\n" +
	"\x05cells\x18\x04 \x03(\x03R\x05cells\x12\x18\n" +
	"\asignals\x18\x05 \x03(\tR\asignals\x12F\n" +
	"\tmovements\x18\x06 \x03(\v2(.micro_traffic_sim.GroupMovementMetadataR\tmovements\x12)\n" +
	"\x10crosswalk_length\x18\a \x01(\x01R\x0fcrosswalkLength\x120\n" +
	"\x04type\x18\b \x01(\x0e2\x1c.micro_traffic_sim.GroupTypeR\x04type\"\xc0\x01\n" +
	"\x15GroupMovementMetadata\x12\x16\n" +
	"\x06source\x18\x01 \x01(\x03R\x06source\x12\x16\n" +
	"\x06target\x18\x02 \x01(\x03R\x06target\x12B\n" +
	"\tdirection\x18\x03 \x01(\x0e2$.micro_traffic_sim.MovementDirectionR\tdirection\x12\x12\n" +
	"\x04flow\x18\x04 \x01(\x01R\x04flow\x12\x1f\n" +
	"\vturn_radius\x18\x05 \x01(\x01R\n" +
	"turnRadius\"{\n" +
	"\n" +
	"SessionTLS\x128\n" +
	"\n" +
	"session_id\x18\x01 \x01(\v2\x19.micro_traffic_sim.UUIDv4R\tsessionId\x123\n" +
	"\x04data\x18\x02 \x03(\v2\x1f.micro_traffic_sim.TrafficLightR\x04data\"<\n" +
	"\x12SessionTLSResponse\x12\x12\n" +
	"\x04code\x18\x01 \x01(\rR\x04code\x12\x12\n" +
	"\x04text\x18\x02 \x01(\tR\x04text*6\n" +
	"\n" +
	"SignalKind\x12\x0f\n" +
	"\vSIGNAL_MAIN\x10\x00\x12\x17\n" +
	"\x13SIGNAL_INTERMEDIATE\x10\x01*V\n" +
	"\tGroupType\x12\x16\n" +
	"\x12GROUP_TYPE_UNKNOWN\x10\x00\x12\x16\n" +
	"\x12GROUP_TYPE_VEHICLE\x10\x01\x12\x19\n" +
	"\x15GROUP_TYPE_PEDESTRIAN\x10\x02*\x8e\x01\n" +
	"\x11MovementDirection\x12\x1e\n" +
	"\x1aMOVEMENT_DIRECTION_UNKNOWN\x10\x00\x12\x1b\n" +
	"\x17MOVEMENT_DIRECTION_LEFT\x10\x01\x12\x1e\n" +
	"\x1aMOVEMENT_DIRECTION_FORWARD\x10\x02\x12\x1c\n" +
	"\x18MOVEMENT_DIRECTION_RIGHT\x10\x03B@Z>github.com/LdDl/micro_traffic_sim_grpc/clients/go;microtrafficb\x06proto3"

var (
	file_tls_proto_rawDescOnce sync.Once
	file_tls_proto_rawDescData []byte
)

func file_tls_proto_rawDescGZIP() []byte {
	file_tls_proto_rawDescOnce.Do(func() {
		file_tls_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_tls_proto_rawDesc), len(file_tls_proto_rawDesc)))
	})
	return file_tls_proto_rawDescData
}

var file_tls_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
var file_tls_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
var file_tls_proto_goTypes = []any{
	(SignalKind)(0),               // 0: micro_traffic_sim.SignalKind
	(GroupType)(0),                // 1: micro_traffic_sim.GroupType
	(MovementDirection)(0),        // 2: micro_traffic_sim.MovementDirection
	(*TrafficLight)(nil),          // 3: micro_traffic_sim.TrafficLight
	(*Group)(nil),                 // 4: micro_traffic_sim.Group
	(*GroupMovementMetadata)(nil), // 5: micro_traffic_sim.GroupMovementMetadata
	(*SessionTLS)(nil),            // 6: micro_traffic_sim.SessionTLS
	(*SessionTLSResponse)(nil),    // 7: micro_traffic_sim.SessionTLSResponse
	(*Point)(nil),                 // 8: micro_traffic_sim.Point
	(*UUIDv4)(nil),                // 9: micro_traffic_sim.UUIDv4
}
var file_tls_proto_depIdxs = []int32{
	8, // 0: micro_traffic_sim.TrafficLight.geom:type_name -> micro_traffic_sim.Point
	4, // 1: micro_traffic_sim.TrafficLight.groups:type_name -> micro_traffic_sim.Group
	0, // 2: micro_traffic_sim.TrafficLight.signals_kinds:type_name -> micro_traffic_sim.SignalKind
	8, // 3: micro_traffic_sim.Group.geom:type_name -> micro_traffic_sim.Point
	5, // 4: micro_traffic_sim.Group.movements:type_name -> micro_traffic_sim.GroupMovementMetadata
	1, // 5: micro_traffic_sim.Group.type:type_name -> micro_traffic_sim.GroupType
	2, // 6: micro_traffic_sim.GroupMovementMetadata.direction:type_name -> micro_traffic_sim.MovementDirection
	9, // 7: micro_traffic_sim.SessionTLS.session_id:type_name -> micro_traffic_sim.UUIDv4
	3, // 8: micro_traffic_sim.SessionTLS.data:type_name -> micro_traffic_sim.TrafficLight
	9, // [9:9] is the sub-list for method output_type
	9, // [9:9] is the sub-list for method input_type
	9, // [9:9] is the sub-list for extension type_name
	9, // [9:9] is the sub-list for extension extendee
	0, // [0:9] is the sub-list for field type_name
}

func init() { file_tls_proto_init() }
func file_tls_proto_init() {
	if File_tls_proto != nil {
		return
	}
	file_uuid_proto_init()
	file_cell_proto_init()
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_tls_proto_rawDesc), len(file_tls_proto_rawDesc)),
			NumEnums:      3,
			NumMessages:   5,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_tls_proto_goTypes,
		DependencyIndexes: file_tls_proto_depIdxs,
		EnumInfos:         file_tls_proto_enumTypes,
		MessageInfos:      file_tls_proto_msgTypes,
	}.Build()
	File_tls_proto = out.File
	file_tls_proto_goTypes = nil
	file_tls_proto_depIdxs = nil
}
