// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v6.32.1
// source: trip.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)
)

// Trip generation pattern, aligned with Rust computation core `TripType`
// https://docs.rs/micro_traffic_sim_core/0.1.0/micro_traffic_sim_core/trips/trip/enum.TripType.html
type TripType int32

const (
	// Default uninitialized state
	TripType_TRIP_TYPE_UNDEFINED TripType = 0
	// Generate vehicles at regular intervals (use time field)
	TripType_TRIP_TYPE_CONSTANT TripType = 1
	// Generate vehicles probabilistically each time step (use probability field)
	TripType_TRIP_TYPE_RANDOM TripType = 2
)

// Enum value maps for TripType.
var (
	TripType_name = map[int32]string{
		0: "TRIP_TYPE_UNDEFINED",
		1: "TRIP_TYPE_CONSTANT",
		2: "TRIP_TYPE_RANDOM",
	}
	TripType_value = map[string]int32{
		"TRIP_TYPE_UNDEFINED": 0,
		"TRIP_TYPE_CONSTANT":  1,
		"TRIP_TYPE_RANDOM":    2,
	}
)

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

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

func (TripType) Descriptor() protoreflect.EnumDescriptor {
	return file_trip_proto_enumTypes[0].Descriptor()
}

func (TripType) Type() protoreflect.EnumType {
	return &file_trip_proto_enumTypes[0]
}

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

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

// Behaviour strategy, aligned with Rust computation core `BehaviourType`
// https://docs.rs/micro_traffic_sim_core/0.1.0/micro_traffic_sim_core/behaviour/enum.BehaviourType.html
type BehaviourType int32

const (
	// Undefined behaviour type.
	BehaviourType_BEHAVIOUR_TYPE_UNDEFINED BehaviourType = 0
	// Movement is prohibited due to external factors (e.g., block, broken vehicle, etc.).
	BehaviourType_BEHAVIOUR_TYPE_BLOCK BehaviourType = 1
	// Agents minimizing travel time.
	BehaviourType_BEHAVIOUR_TYPE_AGGRESSIVE BehaviourType = 2
	// Agents who do not always minimize travel time.
	BehaviourType_BEHAVIOUR_TYPE_COOPERATIVE BehaviourType = 3
	// Agent speed will be limited with a specified value given by the trip.
	BehaviourType_BEHAVIOUR_TYPE_LIMIT_SPEED_BY_TRIP BehaviourType = 4
)

// Enum value maps for BehaviourType.
var (
	BehaviourType_name = map[int32]string{
		0: "BEHAVIOUR_TYPE_UNDEFINED",
		1: "BEHAVIOUR_TYPE_BLOCK",
		2: "BEHAVIOUR_TYPE_AGGRESSIVE",
		3: "BEHAVIOUR_TYPE_COOPERATIVE",
		4: "BEHAVIOUR_TYPE_LIMIT_SPEED_BY_TRIP",
	}
	BehaviourType_value = map[string]int32{
		"BEHAVIOUR_TYPE_UNDEFINED":           0,
		"BEHAVIOUR_TYPE_BLOCK":               1,
		"BEHAVIOUR_TYPE_AGGRESSIVE":          2,
		"BEHAVIOUR_TYPE_COOPERATIVE":         3,
		"BEHAVIOUR_TYPE_LIMIT_SPEED_BY_TRIP": 4,
	}
)

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

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

func (BehaviourType) Descriptor() protoreflect.EnumDescriptor {
	return file_trip_proto_enumTypes[1].Descriptor()
}

func (BehaviourType) Type() protoreflect.EnumType {
	return &file_trip_proto_enumTypes[1]
}

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

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

// Trip definition
type Trip struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Numeric trip identifier
	Id int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Trip type
	TripType TripType `protobuf:"varint,2,opt,name=trip_type,json=tripType,proto3,enum=micro_traffic_sim.TripType" json:"trip_type,omitempty"`
	// Start cell
	FromNode int64 `protobuf:"varint,3,opt,name=from_node,json=fromNode,proto3" json:"from_node,omitempty"`
	// End cell
	ToNode int64 `protobuf:"varint,4,opt,name=to_node,json=toNode,proto3" json:"to_node,omitempty"`
	// Initial speed
	InitialSpeed int64 `protobuf:"varint,5,opt,name=initial_speed,json=initialSpeed,proto3" json:"initial_speed,omitempty"`
	// Vehicle generation probability for trip_type = RANDOM (2)
	Probability float64 `protobuf:"fixed64,6,opt,name=probability,proto3" json:"probability,omitempty"`
	// Agent type
	AgentType AgentType `protobuf:"varint,7,opt,name=agent_type,json=agentType,proto3,enum=micro_traffic_sim.AgentType" json:"agent_type,omitempty"`
	// Behavior strategy
	BehaviourType BehaviourType `protobuf:"varint,8,opt,name=behaviour_type,json=behaviourType,proto3,enum=micro_traffic_sim.BehaviourType" json:"behaviour_type,omitempty"`
	// Vehicle generation time for trip_type = STATIC (1)
	Time int64 `protobuf:"varint,9,opt,name=time,proto3" json:"time,omitempty"`
	// Vehicle generation start time
	StartTime int64 `protobuf:"varint,10,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	// Vehicle generation end time
	EndTime int64 `protobuf:"varint,11,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	// Bus dwell time at stops for agent_type = BUS (2)
	RelaxTime int64 `protobuf:"varint,12,opt,name=relax_time,json=relaxTime,proto3" json:"relax_time,omitempty"`
	// Mandatory bus stops to pass for agent_type = BUS (2)
	Transits      []int64 `protobuf:"varint,13,rep,packed,name=transits,proto3" json:"transits,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Trip) ProtoMessage() {}

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

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

func (x *Trip) GetTripType() TripType {
	if x != nil {
		return x.TripType
	}
	return TripType_TRIP_TYPE_UNDEFINED
}

func (x *Trip) GetFromNode() int64 {
	if x != nil {
		return x.FromNode
	}
	return 0
}

func (x *Trip) GetToNode() int64 {
	if x != nil {
		return x.ToNode
	}
	return 0
}

func (x *Trip) GetInitialSpeed() int64 {
	if x != nil {
		return x.InitialSpeed
	}
	return 0
}

func (x *Trip) GetProbability() float64 {
	if x != nil {
		return x.Probability
	}
	return 0
}

func (x *Trip) GetAgentType() AgentType {
	if x != nil {
		return x.AgentType
	}
	return AgentType_AGENT_TYPE_UNDEFINED
}

func (x *Trip) GetBehaviourType() BehaviourType {
	if x != nil {
		return x.BehaviourType
	}
	return BehaviourType_BEHAVIOUR_TYPE_UNDEFINED
}

func (x *Trip) GetTime() int64 {
	if x != nil {
		return x.Time
	}
	return 0
}

func (x *Trip) GetStartTime() int64 {
	if x != nil {
		return x.StartTime
	}
	return 0
}

func (x *Trip) GetEndTime() int64 {
	if x != nil {
		return x.EndTime
	}
	return 0
}

func (x *Trip) GetRelaxTime() int64 {
	if x != nil {
		return x.RelaxTime
	}
	return 0
}

func (x *Trip) GetTransits() []int64 {
	if x != nil {
		return x.Transits
	}
	return nil
}

// Trip payload bound to a session
type SessionTrip 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"`
	// Trip data. Maximum number of entities per message is 10000 (server-side limit)
	Data          []*Trip `protobuf:"bytes,2,rep,name=data,proto3" json:"data,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SessionTrip) ProtoMessage() {}

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

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

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

// Server response for trip ingest
type SessionTripResponse 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 *SessionTripResponse) Reset() {
	*x = SessionTripResponse{}
	mi := &file_trip_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SessionTripResponse) ProtoMessage() {}

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

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

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

var File_trip_proto protoreflect.FileDescriptor

const file_trip_proto_rawDesc = "" +
	"\n" +
	"\n" +
	"trip.proto\x12\x11micro_traffic_sim\x1a\n" +
	"uuid.proto\x1a\n" +
	"step.proto\"\xdc\x03\n" +
	"\x04Trip\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\x03R\x02id\x128\n" +
	"\ttrip_type\x18\x02 \x01(\x0e2\x1b.micro_traffic_sim.TripTypeR\btripType\x12\x1b\n" +
	"\tfrom_node\x18\x03 \x01(\x03R\bfromNode\x12\x17\n" +
	"\ato_node\x18\x04 \x01(\x03R\x06toNode\x12#\n" +
	"\rinitial_speed\x18\x05 \x01(\x03R\finitialSpeed\x12 \n" +
	"\vprobability\x18\x06 \x01(\x01R\vprobability\x12;\n" +
	"\n" +
	"agent_type\x18\a \x01(\x0e2\x1c.micro_traffic_sim.AgentTypeR\tagentType\x12G\n" +
	"\x0ebehaviour_type\x18\b \x01(\x0e2 .micro_traffic_sim.BehaviourTypeR\rbehaviourType\x12\x12\n" +
	"\x04time\x18\t \x01(\x03R\x04time\x12\x1d\n" +
	"\n" +
	"start_time\x18\n" +
	" \x01(\x03R\tstartTime\x12\x19\n" +
	"\bend_time\x18\v \x01(\x03R\aendTime\x12\x1d\n" +
	"\n" +
	"relax_time\x18\f \x01(\x03R\trelaxTime\x12\x1a\n" +
	"\btransits\x18\r \x03(\x03R\btransits\"t\n" +
	"\vSessionTrip\x128\n" +
	"\n" +
	"session_id\x18\x01 \x01(\v2\x19.micro_traffic_sim.UUIDv4R\tsessionId\x12+\n" +
	"\x04data\x18\x02 \x03(\v2\x17.micro_traffic_sim.TripR\x04data\"=\n" +
	"\x13SessionTripResponse\x12\x12\n" +
	"\x04code\x18\x01 \x01(\rR\x04code\x12\x12\n" +
	"\x04text\x18\x02 \x01(\tR\x04text*Q\n" +
	"\bTripType\x12\x17\n" +
	"\x13TRIP_TYPE_UNDEFINED\x10\x00\x12\x16\n" +
	"\x12TRIP_TYPE_CONSTANT\x10\x01\x12\x14\n" +
	"\x10TRIP_TYPE_RANDOM\x10\x02*\xae\x01\n" +
	"\rBehaviourType\x12\x1c\n" +
	"\x18BEHAVIOUR_TYPE_UNDEFINED\x10\x00\x12\x18\n" +
	"\x14BEHAVIOUR_TYPE_BLOCK\x10\x01\x12\x1d\n" +
	"\x19BEHAVIOUR_TYPE_AGGRESSIVE\x10\x02\x12\x1e\n" +
	"\x1aBEHAVIOUR_TYPE_COOPERATIVE\x10\x03\x12&\n" +
	"\"BEHAVIOUR_TYPE_LIMIT_SPEED_BY_TRIP\x10\x04B@Z>github.com/LdDl/micro_traffic_sim_grpc/clients/go;microtrafficb\x06proto3"

var (
	file_trip_proto_rawDescOnce sync.Once
	file_trip_proto_rawDescData []byte
)

func file_trip_proto_rawDescGZIP() []byte {
	file_trip_proto_rawDescOnce.Do(func() {
		file_trip_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_trip_proto_rawDesc), len(file_trip_proto_rawDesc)))
	})
	return file_trip_proto_rawDescData
}

var file_trip_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_trip_proto_msgTypes = make([]protoimpl.MessageInfo, 3)
var file_trip_proto_goTypes = []any{
	(TripType)(0),               // 0: micro_traffic_sim.TripType
	(BehaviourType)(0),          // 1: micro_traffic_sim.BehaviourType
	(*Trip)(nil),                // 2: micro_traffic_sim.Trip
	(*SessionTrip)(nil),         // 3: micro_traffic_sim.SessionTrip
	(*SessionTripResponse)(nil), // 4: micro_traffic_sim.SessionTripResponse
	(AgentType)(0),              // 5: micro_traffic_sim.AgentType
	(*UUIDv4)(nil),              // 6: micro_traffic_sim.UUIDv4
}
var file_trip_proto_depIdxs = []int32{
	0, // 0: micro_traffic_sim.Trip.trip_type:type_name -> micro_traffic_sim.TripType
	5, // 1: micro_traffic_sim.Trip.agent_type:type_name -> micro_traffic_sim.AgentType
	1, // 2: micro_traffic_sim.Trip.behaviour_type:type_name -> micro_traffic_sim.BehaviourType
	6, // 3: micro_traffic_sim.SessionTrip.session_id:type_name -> micro_traffic_sim.UUIDv4
	2, // 4: micro_traffic_sim.SessionTrip.data:type_name -> micro_traffic_sim.Trip
	5, // [5:5] is the sub-list for method output_type
	5, // [5:5] is the sub-list for method input_type
	5, // [5:5] is the sub-list for extension type_name
	5, // [5:5] is the sub-list for extension extendee
	0, // [0:5] is the sub-list for field type_name
}

func init() { file_trip_proto_init() }
func file_trip_proto_init() {
	if File_trip_proto != nil {
		return
	}
	file_uuid_proto_init()
	file_step_proto_init()
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_trip_proto_rawDesc), len(file_trip_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   3,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_trip_proto_goTypes,
		DependencyIndexes: file_trip_proto_depIdxs,
		EnumInfos:         file_trip_proto_enumTypes,
		MessageInfos:      file_trip_proto_msgTypes,
	}.Build()
	File_trip_proto = out.File
	file_trip_proto_goTypes = nil
	file_trip_proto_depIdxs = nil
}
