From c49c801af232f3570d0c516890dec28a623e7864 Mon Sep 17 00:00:00 2001 From: Mats Linander Date: Mon, 15 Jan 2024 12:11:44 -0500 Subject: [PATCH] remove dep on MobilityData's gtfs rt proto (#27) Keeping a local copy of the realtime proto, and the nyct extension, help users of the package avoid protobuf namespacing issues. --- go.mod | 3 +- go.sum | 6 +- manager_test.go | 2 +- parse/realtime.go | 2 +- parse/realtime_test.go | 3 +- proto/gtfs-realtime-NYCT.pb.go | 642 ++++++ proto/gtfs-realtime-NYCT.proto | 142 ++ proto/gtfs-realtime.pb.go | 3728 ++++++++++++++++++++++++++++++++ proto/gtfs-realtime.proto | 1035 +++++++++ proto/protoc.sh | 11 + realtime_test.go | 2 +- 11 files changed, 5566 insertions(+), 10 deletions(-) create mode 100644 proto/gtfs-realtime-NYCT.pb.go create mode 100644 proto/gtfs-realtime-NYCT.proto create mode 100644 proto/gtfs-realtime.pb.go create mode 100644 proto/gtfs-realtime.proto create mode 100644 proto/protoc.sh diff --git a/go.mod b/go.mod index 6132dc9..0554fc3 100644 --- a/go.mod +++ b/go.mod @@ -10,14 +10,13 @@ require ( github.com/spf13/cobra v1.7.0 github.com/spkg/bom v1.0.0 github.com/stretchr/testify v1.8.4 + google.golang.org/protobuf v1.31.0 ) require ( - github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs v1.0.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect github.com/spf13/pflag v1.0.5 // indirect - google.golang.org/protobuf v1.31.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index c4fbc0f..adcf9ce 100644 --- a/go.sum +++ b/go.sum @@ -1,5 +1,3 @@ -github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs v1.0.0 h1:f4P+fVYmSIWj4b/jvbMdmrmsx/Xb+5xCpYYtVXOdKoc= -github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs v1.0.0/go.mod h1:nSmbVVQSM4lp9gYvVaaTotnRxSwZXEdFnJARofg5V4g= github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= @@ -7,6 +5,7 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs github.com/gocarina/gocsv v0.0.0-20230616125104-99d496ca653d h1:KbPOUXFUDJxwZ04vbmDOc3yuruGvVO+LOa7cVER3yWw= github.com/gocarina/gocsv v0.0.0-20230616125104-99d496ca653d/go.mod h1:5YoVOkjYAQumqlV356Hj3xeYh4BdZuLE0/nRkf2NKkI= github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= +github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= @@ -29,10 +28,9 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+ github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= -google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk= -google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8= google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= diff --git a/manager_test.go b/manager_test.go index 01cb0a7..d0cd9c7 100644 --- a/manager_test.go +++ b/manager_test.go @@ -12,13 +12,13 @@ import ( "testing" "time" - p "github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" proto "google.golang.org/protobuf/proto" "tidbyt.dev/gtfs" "tidbyt.dev/gtfs/downloader" + p "tidbyt.dev/gtfs/proto" "tidbyt.dev/gtfs/storage" "tidbyt.dev/gtfs/testutil" ) diff --git a/parse/realtime.go b/parse/realtime.go index 03b77d1..7dcd476 100644 --- a/parse/realtime.go +++ b/parse/realtime.go @@ -5,8 +5,8 @@ import ( "fmt" "time" - gtfsproto "github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs" proto "google.golang.org/protobuf/proto" + gtfsproto "tidbyt.dev/gtfs/proto" ) type StopTimeUpdateScheduleRelationship int diff --git a/parse/realtime_test.go b/parse/realtime_test.go index e92ea0f..8db5da9 100644 --- a/parse/realtime_test.go +++ b/parse/realtime_test.go @@ -5,10 +5,11 @@ import ( "testing" "time" - p "github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" proto "google.golang.org/protobuf/proto" + + p "tidbyt.dev/gtfs/proto" ) func TestParseRealtimeBadHeader(t *testing.T) { diff --git a/proto/gtfs-realtime-NYCT.pb.go b/proto/gtfs-realtime-NYCT.pb.go new file mode 100644 index 0000000..b91fc55 --- /dev/null +++ b/proto/gtfs-realtime-NYCT.pb.go @@ -0,0 +1,642 @@ +// Copyright 2012 Metropolitan Transportation Authority +// +// Protocol definition NYCT-specific extensions to GTFS-realtime. +// +// As originally posted at: +// +// https://groups.google.com/d/msg/gtfs-realtime/KWJhkXH0kBg/8rlRMxiL-ysJ + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v4.23.4 +// source: gtfs-realtime-NYCT.proto + +package proto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + 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) +) + +// The direction the train is moving. +type NyctTripDescriptor_Direction int32 + +const ( + NyctTripDescriptor_NORTH NyctTripDescriptor_Direction = 1 + NyctTripDescriptor_EAST NyctTripDescriptor_Direction = 2 + NyctTripDescriptor_SOUTH NyctTripDescriptor_Direction = 3 + NyctTripDescriptor_WEST NyctTripDescriptor_Direction = 4 +) + +// Enum value maps for NyctTripDescriptor_Direction. +var ( + NyctTripDescriptor_Direction_name = map[int32]string{ + 1: "NORTH", + 2: "EAST", + 3: "SOUTH", + 4: "WEST", + } + NyctTripDescriptor_Direction_value = map[string]int32{ + "NORTH": 1, + "EAST": 2, + "SOUTH": 3, + "WEST": 4, + } +) + +func (x NyctTripDescriptor_Direction) Enum() *NyctTripDescriptor_Direction { + p := new(NyctTripDescriptor_Direction) + *p = x + return p +} + +func (x NyctTripDescriptor_Direction) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (NyctTripDescriptor_Direction) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_NYCT_proto_enumTypes[0].Descriptor() +} + +func (NyctTripDescriptor_Direction) Type() protoreflect.EnumType { + return &file_gtfs_realtime_NYCT_proto_enumTypes[0] +} + +func (x NyctTripDescriptor_Direction) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *NyctTripDescriptor_Direction) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = NyctTripDescriptor_Direction(num) + return nil +} + +// Deprecated: Use NyctTripDescriptor_Direction.Descriptor instead. +func (NyctTripDescriptor_Direction) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_NYCT_proto_rawDescGZIP(), []int{2, 0} +} + +type TripReplacementPeriod struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The replacement period is for this route + RouteId *string `protobuf:"bytes,1,opt,name=route_id,json=routeId" json:"route_id,omitempty"` + // The start time is omitted, the end time is currently now + 30 minutes for + // all routes of the A division + ReplacementPeriod *TimeRange `protobuf:"bytes,2,opt,name=replacement_period,json=replacementPeriod" json:"replacement_period,omitempty"` +} + +func (x *TripReplacementPeriod) Reset() { + *x = TripReplacementPeriod{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TripReplacementPeriod) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TripReplacementPeriod) ProtoMessage() {} + +func (x *TripReplacementPeriod) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TripReplacementPeriod.ProtoReflect.Descriptor instead. +func (*TripReplacementPeriod) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_NYCT_proto_rawDescGZIP(), []int{0} +} + +func (x *TripReplacementPeriod) GetRouteId() string { + if x != nil && x.RouteId != nil { + return *x.RouteId + } + return "" +} + +func (x *TripReplacementPeriod) GetReplacementPeriod() *TimeRange { + if x != nil { + return x.ReplacementPeriod + } + return nil +} + +// NYCT Subway extensions for the feed header +type NyctFeedHeader struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Version of the NYCT Subway extensions + // The current version is 1.0 + NyctSubwayVersion *string `protobuf:"bytes,1,req,name=nyct_subway_version,json=nyctSubwayVersion" json:"nyct_subway_version,omitempty"` + // For the NYCT Subway, the GTFS-realtime feed replaces any scheduled + // trip within the trip_replacement_period. + // This feed is a full dataset, it contains all trips starting + // in the trip_replacement_period. If a trip from the static GTFS is not + // found in the GTFS-realtime feed, it should be considered as cancelled. + // The replacement period can be different for each route, so here is + // a list of the routes where the trips in the feed replace all + // scheduled trips within the replacement period. + TripReplacementPeriod []*TripReplacementPeriod `protobuf:"bytes,2,rep,name=trip_replacement_period,json=tripReplacementPeriod" json:"trip_replacement_period,omitempty"` +} + +func (x *NyctFeedHeader) Reset() { + *x = NyctFeedHeader{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NyctFeedHeader) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NyctFeedHeader) ProtoMessage() {} + +func (x *NyctFeedHeader) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NyctFeedHeader.ProtoReflect.Descriptor instead. +func (*NyctFeedHeader) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_NYCT_proto_rawDescGZIP(), []int{1} +} + +func (x *NyctFeedHeader) GetNyctSubwayVersion() string { + if x != nil && x.NyctSubwayVersion != nil { + return *x.NyctSubwayVersion + } + return "" +} + +func (x *NyctFeedHeader) GetTripReplacementPeriod() []*TripReplacementPeriod { + if x != nil { + return x.TripReplacementPeriod + } + return nil +} + +// NYCT Subway extensions for the trip descriptor +type NyctTripDescriptor struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The nyct_train_id is meant for internal use only. It provides an + // easy way to associated GTFS-realtime trip identifiers with NYCT rail + // operations identifier + // + // The ATS office system assigns unique train identification (Train ID) to + // each train operating within or ready to enter the mainline of the + // monitored territory. An example of this is 06 0123+ PEL/BBR and is decoded + // as follows: + // + // The first character represents the trip type designator. 0 identifies a + // scheduled revenue trip. Other revenue trip values that are a result of a + // change to the base schedule include; [= reroute], [/ skip stop], [$ turn + // train] also known as shortly lined service. + // + // The second character 6 represents the trip line i.e. number 6 train The + // third set of characters identify the decoded origin time. The last + // character may be blank "on the whole minute" or + "30 seconds" + // + // Note: Origin times will not change when there is a trip type change. This + // is followed by a three character "Origin Location" / "Destination + // Location" + TrainId *string `protobuf:"bytes,1,opt,name=train_id,json=trainId" json:"train_id,omitempty"` + // This trip has been assigned to a physical train. If true, this trip is + // already underway or most likely will depart shortly. + // + // Train Assignment is a function of the Automatic Train Supervision (ATS) + // office system used by NYCT Rail Operations to monitor and track train + // movements. ATS provides the ability to "assign" the nyct_train_id + // attribute when a physical train is at its origin terminal. These assigned + // trips have the is_assigned field set in the TripDescriptor. + // + // When a train is at a terminal but has not been given a work program it is + // declared unassigned and is tagged as such. Unassigned trains can be moved + // to a storage location or assigned a nyct_train_id when a determination for + // service is made. + IsAssigned *bool `protobuf:"varint,2,opt,name=is_assigned,json=isAssigned" json:"is_assigned,omitempty"` + // Uptown and Bronx-bound trains are moving NORTH. + // Times Square Shuttle to Grand Central is also northbound. + // + // Downtown and Brooklyn-bound trains are moving SOUTH. + // Times Square Shuttle to Times Square is also southbound. + // + // EAST and WEST are not used currently. + Direction *NyctTripDescriptor_Direction `protobuf:"varint,3,opt,name=direction,enum=transit_realtime.NyctTripDescriptor_Direction" json:"direction,omitempty"` +} + +func (x *NyctTripDescriptor) Reset() { + *x = NyctTripDescriptor{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NyctTripDescriptor) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NyctTripDescriptor) ProtoMessage() {} + +func (x *NyctTripDescriptor) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NyctTripDescriptor.ProtoReflect.Descriptor instead. +func (*NyctTripDescriptor) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_NYCT_proto_rawDescGZIP(), []int{2} +} + +func (x *NyctTripDescriptor) GetTrainId() string { + if x != nil && x.TrainId != nil { + return *x.TrainId + } + return "" +} + +func (x *NyctTripDescriptor) GetIsAssigned() bool { + if x != nil && x.IsAssigned != nil { + return *x.IsAssigned + } + return false +} + +func (x *NyctTripDescriptor) GetDirection() NyctTripDescriptor_Direction { + if x != nil && x.Direction != nil { + return *x.Direction + } + return NyctTripDescriptor_NORTH +} + +// NYCT Subway extensions for the stop time update +type NyctStopTimeUpdate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Provides the planned station arrival track. The following is the Manhattan + // track configurations: + // 1: southbound local + // 2: southbound express + // 3: northbound express + // 4: northbound local + // + // In the Bronx (except Dyre Ave line) + // M: bi-directional express (in the AM express to Manhattan, in the PM + // express away). + // + // The Dyre Ave line is configured: + // 1: southbound + // 2: northbound + // 3: bi-directional + ScheduledTrack *string `protobuf:"bytes,1,opt,name=scheduled_track,json=scheduledTrack" json:"scheduled_track,omitempty"` + // This is the actual track that the train is operating on and can be used to + // determine if a train is operating according to its current schedule + // (plan). + // + // The actual track is known only shortly before the train reaches a station, + // typically not before it leaves the previous station. Therefore, the NYCT + // feed sets this field only for the first station of the remaining trip. + // + // Different actual and scheduled track is the result of manually rerouting a + // train off it scheduled path. When this occurs, prediction data may become + // unreliable since the train is no longer operating in accordance to its + // schedule. The rules engine for the 'countdown' clocks will remove this + // train from all schedule stations. + ActualTrack *string `protobuf:"bytes,2,opt,name=actual_track,json=actualTrack" json:"actual_track,omitempty"` +} + +func (x *NyctStopTimeUpdate) Reset() { + *x = NyctStopTimeUpdate{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NyctStopTimeUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NyctStopTimeUpdate) ProtoMessage() {} + +func (x *NyctStopTimeUpdate) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_NYCT_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NyctStopTimeUpdate.ProtoReflect.Descriptor instead. +func (*NyctStopTimeUpdate) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_NYCT_proto_rawDescGZIP(), []int{3} +} + +func (x *NyctStopTimeUpdate) GetScheduledTrack() string { + if x != nil && x.ScheduledTrack != nil { + return *x.ScheduledTrack + } + return "" +} + +func (x *NyctStopTimeUpdate) GetActualTrack() string { + if x != nil && x.ActualTrack != nil { + return *x.ActualTrack + } + return "" +} + +var file_gtfs_realtime_NYCT_proto_extTypes = []protoimpl.ExtensionInfo{ + { + ExtendedType: (*FeedHeader)(nil), + ExtensionType: (*NyctFeedHeader)(nil), + Field: 1001, + Name: "transit_realtime.nyct_feed_header", + Tag: "bytes,1001,opt,name=nyct_feed_header", + Filename: "gtfs-realtime-NYCT.proto", + }, + { + ExtendedType: (*TripDescriptor)(nil), + ExtensionType: (*NyctTripDescriptor)(nil), + Field: 1001, + Name: "transit_realtime.nyct_trip_descriptor", + Tag: "bytes,1001,opt,name=nyct_trip_descriptor", + Filename: "gtfs-realtime-NYCT.proto", + }, + { + ExtendedType: (*TripUpdate_StopTimeUpdate)(nil), + ExtensionType: (*NyctStopTimeUpdate)(nil), + Field: 1001, + Name: "transit_realtime.nyct_stop_time_update", + Tag: "bytes,1001,opt,name=nyct_stop_time_update", + Filename: "gtfs-realtime-NYCT.proto", + }, +} + +// Extension fields to FeedHeader. +var ( + // optional transit_realtime.NyctFeedHeader nyct_feed_header = 1001; + E_NyctFeedHeader = &file_gtfs_realtime_NYCT_proto_extTypes[0] +) + +// Extension fields to TripDescriptor. +var ( + // optional transit_realtime.NyctTripDescriptor nyct_trip_descriptor = 1001; + E_NyctTripDescriptor = &file_gtfs_realtime_NYCT_proto_extTypes[1] +) + +// Extension fields to TripUpdate_StopTimeUpdate. +var ( + // optional transit_realtime.NyctStopTimeUpdate nyct_stop_time_update = 1001; + E_NyctStopTimeUpdate = &file_gtfs_realtime_NYCT_proto_extTypes[2] +) + +var File_gtfs_realtime_NYCT_proto protoreflect.FileDescriptor + +var file_gtfs_realtime_NYCT_proto_rawDesc = []byte{ + 0x0a, 0x18, 0x67, 0x74, 0x66, 0x73, 0x2d, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2d, + 0x4e, 0x59, 0x43, 0x54, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x1a, 0x13, 0x67, 0x74, + 0x66, 0x73, 0x2d, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x22, 0x7e, 0x0a, 0x15, 0x54, 0x72, 0x69, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x49, 0x64, 0x12, 0x4a, 0x0a, 0x12, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1b, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, + 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x11, + 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, + 0x64, 0x22, 0xa1, 0x01, 0x0a, 0x0e, 0x4e, 0x79, 0x63, 0x74, 0x46, 0x65, 0x65, 0x64, 0x48, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x12, 0x2e, 0x0a, 0x13, 0x6e, 0x79, 0x63, 0x74, 0x5f, 0x73, 0x75, 0x62, + 0x77, 0x61, 0x79, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x02, 0x28, + 0x09, 0x52, 0x11, 0x6e, 0x79, 0x63, 0x74, 0x53, 0x75, 0x62, 0x77, 0x61, 0x79, 0x56, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x5f, 0x0a, 0x17, 0x74, 0x72, 0x69, 0x70, 0x5f, 0x72, 0x65, 0x70, + 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, + 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x52, 0x65, 0x70, + 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x52, 0x15, + 0x74, 0x72, 0x69, 0x70, 0x52, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x50, + 0x65, 0x72, 0x69, 0x6f, 0x64, 0x22, 0xd5, 0x01, 0x0a, 0x12, 0x4e, 0x79, 0x63, 0x74, 0x54, 0x72, + 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x19, 0x0a, 0x08, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x74, 0x72, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x69, 0x73, 0x5f, 0x61, 0x73, + 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x69, 0x73, + 0x41, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x12, 0x4c, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2e, 0x2e, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x4e, + 0x79, 0x63, 0x74, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x2e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x09, 0x64, 0x69, 0x72, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x35, 0x0a, 0x09, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x09, 0x0a, 0x05, 0x4e, 0x4f, 0x52, 0x54, 0x48, 0x10, 0x01, 0x12, 0x08, + 0x0a, 0x04, 0x45, 0x41, 0x53, 0x54, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x4f, 0x55, 0x54, + 0x48, 0x10, 0x03, 0x12, 0x08, 0x0a, 0x04, 0x57, 0x45, 0x53, 0x54, 0x10, 0x04, 0x22, 0x60, 0x0a, + 0x12, 0x4e, 0x79, 0x63, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, + 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x73, 0x63, + 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x64, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x12, 0x21, 0x0a, 0x0c, + 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x5f, 0x74, 0x72, 0x61, 0x63, 0x6b, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0b, 0x61, 0x63, 0x74, 0x75, 0x61, 0x6c, 0x54, 0x72, 0x61, 0x63, 0x6b, 0x3a, + 0x69, 0x0a, 0x10, 0x6e, 0x79, 0x63, 0x74, 0x5f, 0x66, 0x65, 0x65, 0x64, 0x5f, 0x68, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x12, 0x1c, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, + 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x46, 0x65, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x4e, 0x79, 0x63, 0x74, + 0x46, 0x65, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x0e, 0x6e, 0x79, 0x63, 0x74, + 0x46, 0x65, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x3a, 0x79, 0x0a, 0x14, 0x6e, 0x79, + 0x63, 0x74, 0x5f, 0x74, 0x72, 0x69, 0x70, 0x5f, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, + 0x6f, 0x72, 0x12, 0x20, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, + 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x4e, + 0x79, 0x63, 0x74, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, + 0x72, 0x52, 0x12, 0x6e, 0x79, 0x63, 0x74, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x70, 0x74, 0x6f, 0x72, 0x3a, 0x85, 0x01, 0x0a, 0x15, 0x6e, 0x79, 0x63, 0x74, 0x5f, 0x73, + 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, + 0x2b, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, + 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x74, + 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x18, 0xe9, 0x07, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, + 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x4e, 0x79, 0x63, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x54, + 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x12, 0x6e, 0x79, 0x63, 0x74, 0x53, + 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x42, 0x1d, 0x0a, + 0x1b, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x69, 0x74, 0x2e, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, +} + +var ( + file_gtfs_realtime_NYCT_proto_rawDescOnce sync.Once + file_gtfs_realtime_NYCT_proto_rawDescData = file_gtfs_realtime_NYCT_proto_rawDesc +) + +func file_gtfs_realtime_NYCT_proto_rawDescGZIP() []byte { + file_gtfs_realtime_NYCT_proto_rawDescOnce.Do(func() { + file_gtfs_realtime_NYCT_proto_rawDescData = protoimpl.X.CompressGZIP(file_gtfs_realtime_NYCT_proto_rawDescData) + }) + return file_gtfs_realtime_NYCT_proto_rawDescData +} + +var file_gtfs_realtime_NYCT_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_gtfs_realtime_NYCT_proto_msgTypes = make([]protoimpl.MessageInfo, 4) +var file_gtfs_realtime_NYCT_proto_goTypes = []interface{}{ + (NyctTripDescriptor_Direction)(0), // 0: transit_realtime.NyctTripDescriptor.Direction + (*TripReplacementPeriod)(nil), // 1: transit_realtime.TripReplacementPeriod + (*NyctFeedHeader)(nil), // 2: transit_realtime.NyctFeedHeader + (*NyctTripDescriptor)(nil), // 3: transit_realtime.NyctTripDescriptor + (*NyctStopTimeUpdate)(nil), // 4: transit_realtime.NyctStopTimeUpdate + (*TimeRange)(nil), // 5: transit_realtime.TimeRange + (*FeedHeader)(nil), // 6: transit_realtime.FeedHeader + (*TripDescriptor)(nil), // 7: transit_realtime.TripDescriptor + (*TripUpdate_StopTimeUpdate)(nil), // 8: transit_realtime.TripUpdate.StopTimeUpdate +} +var file_gtfs_realtime_NYCT_proto_depIdxs = []int32{ + 5, // 0: transit_realtime.TripReplacementPeriod.replacement_period:type_name -> transit_realtime.TimeRange + 1, // 1: transit_realtime.NyctFeedHeader.trip_replacement_period:type_name -> transit_realtime.TripReplacementPeriod + 0, // 2: transit_realtime.NyctTripDescriptor.direction:type_name -> transit_realtime.NyctTripDescriptor.Direction + 6, // 3: transit_realtime.nyct_feed_header:extendee -> transit_realtime.FeedHeader + 7, // 4: transit_realtime.nyct_trip_descriptor:extendee -> transit_realtime.TripDescriptor + 8, // 5: transit_realtime.nyct_stop_time_update:extendee -> transit_realtime.TripUpdate.StopTimeUpdate + 2, // 6: transit_realtime.nyct_feed_header:type_name -> transit_realtime.NyctFeedHeader + 3, // 7: transit_realtime.nyct_trip_descriptor:type_name -> transit_realtime.NyctTripDescriptor + 4, // 8: transit_realtime.nyct_stop_time_update:type_name -> transit_realtime.NyctStopTimeUpdate + 9, // [9:9] is the sub-list for method output_type + 9, // [9:9] is the sub-list for method input_type + 6, // [6:9] is the sub-list for extension type_name + 3, // [3:6] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_gtfs_realtime_NYCT_proto_init() } +func file_gtfs_realtime_NYCT_proto_init() { + if File_gtfs_realtime_NYCT_proto != nil { + return + } + file_gtfs_realtime_proto_init() + if !protoimpl.UnsafeEnabled { + file_gtfs_realtime_NYCT_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TripReplacementPeriod); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gtfs_realtime_NYCT_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NyctFeedHeader); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gtfs_realtime_NYCT_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NyctTripDescriptor); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_gtfs_realtime_NYCT_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NyctStopTimeUpdate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_gtfs_realtime_NYCT_proto_rawDesc, + NumEnums: 1, + NumMessages: 4, + NumExtensions: 3, + NumServices: 0, + }, + GoTypes: file_gtfs_realtime_NYCT_proto_goTypes, + DependencyIndexes: file_gtfs_realtime_NYCT_proto_depIdxs, + EnumInfos: file_gtfs_realtime_NYCT_proto_enumTypes, + MessageInfos: file_gtfs_realtime_NYCT_proto_msgTypes, + ExtensionInfos: file_gtfs_realtime_NYCT_proto_extTypes, + }.Build() + File_gtfs_realtime_NYCT_proto = out.File + file_gtfs_realtime_NYCT_proto_rawDesc = nil + file_gtfs_realtime_NYCT_proto_goTypes = nil + file_gtfs_realtime_NYCT_proto_depIdxs = nil +} diff --git a/proto/gtfs-realtime-NYCT.proto b/proto/gtfs-realtime-NYCT.proto new file mode 100644 index 0000000..96cd785 --- /dev/null +++ b/proto/gtfs-realtime-NYCT.proto @@ -0,0 +1,142 @@ +// Copyright 2012 Metropolitan Transportation Authority +// +// Protocol definition NYCT-specific extensions to GTFS-realtime. +// +// As originally posted at: +// +// https://groups.google.com/d/msg/gtfs-realtime/KWJhkXH0kBg/8rlRMxiL-ysJ + +syntax = "proto2"; + +import "gtfs-realtime.proto"; + +option java_package = "com.google.transit.realtime"; +package transit_realtime; + +message TripReplacementPeriod { + // The replacement period is for this route + optional string route_id = 1; + // The start time is omitted, the end time is currently now + 30 minutes for + // all routes of the A division + optional transit_realtime.TimeRange replacement_period = 2; +} + +// NYCT Subway extensions for the feed header +message NyctFeedHeader { + // Version of the NYCT Subway extensions + // The current version is 1.0 + required string nyct_subway_version = 1; + // For the NYCT Subway, the GTFS-realtime feed replaces any scheduled + // trip within the trip_replacement_period. + // This feed is a full dataset, it contains all trips starting + // in the trip_replacement_period. If a trip from the static GTFS is not + // found in the GTFS-realtime feed, it should be considered as cancelled. + // The replacement period can be different for each route, so here is + // a list of the routes where the trips in the feed replace all + // scheduled trips within the replacement period. + repeated TripReplacementPeriod trip_replacement_period = 2; +} + +extend FeedHeader { + optional NyctFeedHeader nyct_feed_header = 1001; +} + +// NYCT Subway extensions for the trip descriptor +message NyctTripDescriptor { + // The nyct_train_id is meant for internal use only. It provides an + // easy way to associated GTFS-realtime trip identifiers with NYCT rail + // operations identifier + // + // The ATS office system assigns unique train identification (Train ID) to + // each train operating within or ready to enter the mainline of the + // monitored territory. An example of this is 06 0123+ PEL/BBR and is decoded + // as follows: + // + // The first character represents the trip type designator. 0 identifies a + // scheduled revenue trip. Other revenue trip values that are a result of a + // change to the base schedule include; [= reroute], [/ skip stop], [$ turn + // train] also known as shortly lined service. + // + // The second character 6 represents the trip line i.e. number 6 train The + // third set of characters identify the decoded origin time. The last + // character may be blank "on the whole minute" or + "30 seconds" + // + // Note: Origin times will not change when there is a trip type change. This + // is followed by a three character "Origin Location" / "Destination + // Location" + optional string train_id = 1; + + // This trip has been assigned to a physical train. If true, this trip is + // already underway or most likely will depart shortly. + // + // Train Assignment is a function of the Automatic Train Supervision (ATS) + // office system used by NYCT Rail Operations to monitor and track train + // movements. ATS provides the ability to "assign" the nyct_train_id + // attribute when a physical train is at its origin terminal. These assigned + // trips have the is_assigned field set in the TripDescriptor. + // + // When a train is at a terminal but has not been given a work program it is + // declared unassigned and is tagged as such. Unassigned trains can be moved + // to a storage location or assigned a nyct_train_id when a determination for + // service is made. + optional bool is_assigned = 2; + + // The direction the train is moving. + enum Direction { + NORTH = 1; + EAST = 2; + SOUTH = 3; + WEST = 4; + } + // Uptown and Bronx-bound trains are moving NORTH. + // Times Square Shuttle to Grand Central is also northbound. + // + // Downtown and Brooklyn-bound trains are moving SOUTH. + // Times Square Shuttle to Times Square is also southbound. + // + // EAST and WEST are not used currently. + optional Direction direction = 3; +} + +extend transit_realtime.TripDescriptor { + optional NyctTripDescriptor nyct_trip_descriptor = 1001; +} + +// NYCT Subway extensions for the stop time update +message NyctStopTimeUpdate { + // Provides the planned station arrival track. The following is the Manhattan + // track configurations: + // 1: southbound local + // 2: southbound express + // 3: northbound express + // 4: northbound local + // + // In the Bronx (except Dyre Ave line) + // M: bi-directional express (in the AM express to Manhattan, in the PM + // express away). + // + // The Dyre Ave line is configured: + // 1: southbound + // 2: northbound + // 3: bi-directional + optional string scheduled_track = 1; + + // This is the actual track that the train is operating on and can be used to + // determine if a train is operating according to its current schedule + // (plan). + // + // The actual track is known only shortly before the train reaches a station, + // typically not before it leaves the previous station. Therefore, the NYCT + // feed sets this field only for the first station of the remaining trip. + // + // Different actual and scheduled track is the result of manually rerouting a + // train off it scheduled path. When this occurs, prediction data may become + // unreliable since the train is no longer operating in accordance to its + // schedule. The rules engine for the 'countdown' clocks will remove this + // train from all schedule stations. + optional string actual_track = 2; +} + +extend transit_realtime.TripUpdate.StopTimeUpdate { + optional NyctStopTimeUpdate nyct_stop_time_update = 1001; +} diff --git a/proto/gtfs-realtime.pb.go b/proto/gtfs-realtime.pb.go new file mode 100644 index 0000000..3bf6811 --- /dev/null +++ b/proto/gtfs-realtime.pb.go @@ -0,0 +1,3728 @@ +// Copyright 2015 The GTFS Specifications Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Protocol definition file for GTFS Realtime. +// +// GTFS Realtime lets transit agencies provide consumers with realtime +// information about disruptions to their service (stations closed, lines not +// operating, important delays etc), location of their vehicles and expected +// arrival times. +// +// This protocol is published at: +// https://github.com/google/transit/tree/master/gtfs-realtime + +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.28.1 +// protoc v4.23.4 +// source: gtfs-realtime.proto + +package proto + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + 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) +) + +// Determines whether the current fetch is incremental. Currently, +// DIFFERENTIAL mode is unsupported and behavior is unspecified for feeds +// that use this mode. There are discussions on the GTFS Realtime mailing +// list around fully specifying the behavior of DIFFERENTIAL mode and the +// documentation will be updated when those discussions are finalized. +type FeedHeader_Incrementality int32 + +const ( + FeedHeader_FULL_DATASET FeedHeader_Incrementality = 0 + FeedHeader_DIFFERENTIAL FeedHeader_Incrementality = 1 +) + +// Enum value maps for FeedHeader_Incrementality. +var ( + FeedHeader_Incrementality_name = map[int32]string{ + 0: "FULL_DATASET", + 1: "DIFFERENTIAL", + } + FeedHeader_Incrementality_value = map[string]int32{ + "FULL_DATASET": 0, + "DIFFERENTIAL": 1, + } +) + +func (x FeedHeader_Incrementality) Enum() *FeedHeader_Incrementality { + p := new(FeedHeader_Incrementality) + *p = x + return p +} + +func (x FeedHeader_Incrementality) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (FeedHeader_Incrementality) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[0].Descriptor() +} + +func (FeedHeader_Incrementality) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[0] +} + +func (x FeedHeader_Incrementality) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *FeedHeader_Incrementality) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = FeedHeader_Incrementality(num) + return nil +} + +// Deprecated: Use FeedHeader_Incrementality.Descriptor instead. +func (FeedHeader_Incrementality) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{1, 0} +} + +// The relation between the StopTimeEvents and the static schedule. +type TripUpdate_StopTimeUpdate_ScheduleRelationship int32 + +const ( + // The vehicle is proceeding in accordance with its static schedule of + // stops, although not necessarily according to the times of the schedule. + // At least one of arrival and departure must be provided. If the schedule + // for this stop contains both arrival and departure times then so must + // this update. Frequency-based trips (GTFS frequencies.txt with exact_times = 0) + // should not have a SCHEDULED value and should use UNSCHEDULED instead. + TripUpdate_StopTimeUpdate_SCHEDULED TripUpdate_StopTimeUpdate_ScheduleRelationship = 0 + // The stop is skipped, i.e., the vehicle will not stop at this stop. + // Arrival and departure are optional. + TripUpdate_StopTimeUpdate_SKIPPED TripUpdate_StopTimeUpdate_ScheduleRelationship = 1 + // No StopTimeEvents are given for this stop. + // The main intention for this value is to give time predictions only for + // part of a trip, i.e., if the last update for a trip has a NO_DATA + // specifier, then StopTimeEvents for the rest of the stops in the trip + // are considered to be unspecified as well. + // Neither arrival nor departure should be supplied. + TripUpdate_StopTimeUpdate_NO_DATA TripUpdate_StopTimeUpdate_ScheduleRelationship = 2 + // The vehicle is operating a trip defined in GTFS frequencies.txt with exact_times = 0. + // This value should not be used for trips that are not defined in GTFS frequencies.txt, + // or trips in GTFS frequencies.txt with exact_times = 1. Trips containing StopTimeUpdates + // with ScheduleRelationship=UNSCHEDULED must also set TripDescriptor.ScheduleRelationship=UNSCHEDULED. + // NOTE: This field is still experimental, and subject to change. It may be + // formally adopted in the future. + TripUpdate_StopTimeUpdate_UNSCHEDULED TripUpdate_StopTimeUpdate_ScheduleRelationship = 3 +) + +// Enum value maps for TripUpdate_StopTimeUpdate_ScheduleRelationship. +var ( + TripUpdate_StopTimeUpdate_ScheduleRelationship_name = map[int32]string{ + 0: "SCHEDULED", + 1: "SKIPPED", + 2: "NO_DATA", + 3: "UNSCHEDULED", + } + TripUpdate_StopTimeUpdate_ScheduleRelationship_value = map[string]int32{ + "SCHEDULED": 0, + "SKIPPED": 1, + "NO_DATA": 2, + "UNSCHEDULED": 3, + } +) + +func (x TripUpdate_StopTimeUpdate_ScheduleRelationship) Enum() *TripUpdate_StopTimeUpdate_ScheduleRelationship { + p := new(TripUpdate_StopTimeUpdate_ScheduleRelationship) + *p = x + return p +} + +func (x TripUpdate_StopTimeUpdate_ScheduleRelationship) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TripUpdate_StopTimeUpdate_ScheduleRelationship) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[1].Descriptor() +} + +func (TripUpdate_StopTimeUpdate_ScheduleRelationship) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[1] +} + +func (x TripUpdate_StopTimeUpdate_ScheduleRelationship) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *TripUpdate_StopTimeUpdate_ScheduleRelationship) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = TripUpdate_StopTimeUpdate_ScheduleRelationship(num) + return nil +} + +// Deprecated: Use TripUpdate_StopTimeUpdate_ScheduleRelationship.Descriptor instead. +func (TripUpdate_StopTimeUpdate_ScheduleRelationship) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{3, 1, 0} +} + +type VehiclePosition_VehicleStopStatus int32 + +const ( + // The vehicle is just about to arrive at the stop (on a stop + // display, the vehicle symbol typically flashes). + VehiclePosition_INCOMING_AT VehiclePosition_VehicleStopStatus = 0 + // The vehicle is standing at the stop. + VehiclePosition_STOPPED_AT VehiclePosition_VehicleStopStatus = 1 + // The vehicle has departed and is in transit to the next stop. + VehiclePosition_IN_TRANSIT_TO VehiclePosition_VehicleStopStatus = 2 +) + +// Enum value maps for VehiclePosition_VehicleStopStatus. +var ( + VehiclePosition_VehicleStopStatus_name = map[int32]string{ + 0: "INCOMING_AT", + 1: "STOPPED_AT", + 2: "IN_TRANSIT_TO", + } + VehiclePosition_VehicleStopStatus_value = map[string]int32{ + "INCOMING_AT": 0, + "STOPPED_AT": 1, + "IN_TRANSIT_TO": 2, + } +) + +func (x VehiclePosition_VehicleStopStatus) Enum() *VehiclePosition_VehicleStopStatus { + p := new(VehiclePosition_VehicleStopStatus) + *p = x + return p +} + +func (x VehiclePosition_VehicleStopStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VehiclePosition_VehicleStopStatus) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[2].Descriptor() +} + +func (VehiclePosition_VehicleStopStatus) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[2] +} + +func (x VehiclePosition_VehicleStopStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *VehiclePosition_VehicleStopStatus) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = VehiclePosition_VehicleStopStatus(num) + return nil +} + +// Deprecated: Use VehiclePosition_VehicleStopStatus.Descriptor instead. +func (VehiclePosition_VehicleStopStatus) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{4, 0} +} + +// Congestion level that is affecting this vehicle. +type VehiclePosition_CongestionLevel int32 + +const ( + VehiclePosition_UNKNOWN_CONGESTION_LEVEL VehiclePosition_CongestionLevel = 0 + VehiclePosition_RUNNING_SMOOTHLY VehiclePosition_CongestionLevel = 1 + VehiclePosition_STOP_AND_GO VehiclePosition_CongestionLevel = 2 + VehiclePosition_CONGESTION VehiclePosition_CongestionLevel = 3 + VehiclePosition_SEVERE_CONGESTION VehiclePosition_CongestionLevel = 4 // People leaving their cars. +) + +// Enum value maps for VehiclePosition_CongestionLevel. +var ( + VehiclePosition_CongestionLevel_name = map[int32]string{ + 0: "UNKNOWN_CONGESTION_LEVEL", + 1: "RUNNING_SMOOTHLY", + 2: "STOP_AND_GO", + 3: "CONGESTION", + 4: "SEVERE_CONGESTION", + } + VehiclePosition_CongestionLevel_value = map[string]int32{ + "UNKNOWN_CONGESTION_LEVEL": 0, + "RUNNING_SMOOTHLY": 1, + "STOP_AND_GO": 2, + "CONGESTION": 3, + "SEVERE_CONGESTION": 4, + } +) + +func (x VehiclePosition_CongestionLevel) Enum() *VehiclePosition_CongestionLevel { + p := new(VehiclePosition_CongestionLevel) + *p = x + return p +} + +func (x VehiclePosition_CongestionLevel) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VehiclePosition_CongestionLevel) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[3].Descriptor() +} + +func (VehiclePosition_CongestionLevel) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[3] +} + +func (x VehiclePosition_CongestionLevel) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *VehiclePosition_CongestionLevel) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = VehiclePosition_CongestionLevel(num) + return nil +} + +// Deprecated: Use VehiclePosition_CongestionLevel.Descriptor instead. +func (VehiclePosition_CongestionLevel) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{4, 1} +} + +// The state of passenger occupancy for the vehicle or carriage. +// Individual producers may not publish all OccupancyStatus values. Therefore, consumers +// must not assume that the OccupancyStatus values follow a linear scale. +// Consumers should represent OccupancyStatus values as the state indicated +// and intended by the producer. Likewise, producers must use OccupancyStatus values that +// correspond to actual vehicle occupancy states. +// For describing passenger occupancy levels on a linear scale, see `occupancy_percentage`. +// This field is still experimental, and subject to change. It may be formally adopted in the future. +type VehiclePosition_OccupancyStatus int32 + +const ( + // The vehicle or carriage is considered empty by most measures, and has few or no + // passengers onboard, but is still accepting passengers. + VehiclePosition_EMPTY VehiclePosition_OccupancyStatus = 0 + // The vehicle or carriage has a large number of seats available. + // The amount of free seats out of the total seats available to be + // considered large enough to fall into this category is determined at the + // discretion of the producer. + VehiclePosition_MANY_SEATS_AVAILABLE VehiclePosition_OccupancyStatus = 1 + // The vehicle or carriage has a relatively small number of seats available. + // The amount of free seats out of the total seats available to be + // considered small enough to fall into this category is determined at the + // discretion of the feed producer. + VehiclePosition_FEW_SEATS_AVAILABLE VehiclePosition_OccupancyStatus = 2 + // The vehicle or carriage can currently accommodate only standing passengers. + VehiclePosition_STANDING_ROOM_ONLY VehiclePosition_OccupancyStatus = 3 + // The vehicle or carriage can currently accommodate only standing passengers + // and has limited space for them. + VehiclePosition_CRUSHED_STANDING_ROOM_ONLY VehiclePosition_OccupancyStatus = 4 + // The vehicle or carriage is considered full by most measures, but may still be + // allowing passengers to board. + VehiclePosition_FULL VehiclePosition_OccupancyStatus = 5 + // The vehicle or carriage is not accepting passengers, but usually accepts passengers for boarding. + VehiclePosition_NOT_ACCEPTING_PASSENGERS VehiclePosition_OccupancyStatus = 6 + // The vehicle or carriage doesn't have any occupancy data available at that time. + VehiclePosition_NO_DATA_AVAILABLE VehiclePosition_OccupancyStatus = 7 + // The vehicle or carriage is not boardable and never accepts passengers. + // Useful for special vehicles or carriages (engine, maintenance carriage, etc…). + VehiclePosition_NOT_BOARDABLE VehiclePosition_OccupancyStatus = 8 +) + +// Enum value maps for VehiclePosition_OccupancyStatus. +var ( + VehiclePosition_OccupancyStatus_name = map[int32]string{ + 0: "EMPTY", + 1: "MANY_SEATS_AVAILABLE", + 2: "FEW_SEATS_AVAILABLE", + 3: "STANDING_ROOM_ONLY", + 4: "CRUSHED_STANDING_ROOM_ONLY", + 5: "FULL", + 6: "NOT_ACCEPTING_PASSENGERS", + 7: "NO_DATA_AVAILABLE", + 8: "NOT_BOARDABLE", + } + VehiclePosition_OccupancyStatus_value = map[string]int32{ + "EMPTY": 0, + "MANY_SEATS_AVAILABLE": 1, + "FEW_SEATS_AVAILABLE": 2, + "STANDING_ROOM_ONLY": 3, + "CRUSHED_STANDING_ROOM_ONLY": 4, + "FULL": 5, + "NOT_ACCEPTING_PASSENGERS": 6, + "NO_DATA_AVAILABLE": 7, + "NOT_BOARDABLE": 8, + } +) + +func (x VehiclePosition_OccupancyStatus) Enum() *VehiclePosition_OccupancyStatus { + p := new(VehiclePosition_OccupancyStatus) + *p = x + return p +} + +func (x VehiclePosition_OccupancyStatus) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VehiclePosition_OccupancyStatus) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[4].Descriptor() +} + +func (VehiclePosition_OccupancyStatus) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[4] +} + +func (x VehiclePosition_OccupancyStatus) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *VehiclePosition_OccupancyStatus) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = VehiclePosition_OccupancyStatus(num) + return nil +} + +// Deprecated: Use VehiclePosition_OccupancyStatus.Descriptor instead. +func (VehiclePosition_OccupancyStatus) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{4, 2} +} + +// Cause of this alert. If cause_detail is included, then Cause must also be included. +type Alert_Cause int32 + +const ( + Alert_UNKNOWN_CAUSE Alert_Cause = 1 + Alert_OTHER_CAUSE Alert_Cause = 2 // Not machine-representable. + Alert_TECHNICAL_PROBLEM Alert_Cause = 3 + Alert_STRIKE Alert_Cause = 4 // Public transit agency employees stopped working. + Alert_DEMONSTRATION Alert_Cause = 5 // People are blocking the streets. + Alert_ACCIDENT Alert_Cause = 6 + Alert_HOLIDAY Alert_Cause = 7 + Alert_WEATHER Alert_Cause = 8 + Alert_MAINTENANCE Alert_Cause = 9 + Alert_CONSTRUCTION Alert_Cause = 10 + Alert_POLICE_ACTIVITY Alert_Cause = 11 + Alert_MEDICAL_EMERGENCY Alert_Cause = 12 +) + +// Enum value maps for Alert_Cause. +var ( + Alert_Cause_name = map[int32]string{ + 1: "UNKNOWN_CAUSE", + 2: "OTHER_CAUSE", + 3: "TECHNICAL_PROBLEM", + 4: "STRIKE", + 5: "DEMONSTRATION", + 6: "ACCIDENT", + 7: "HOLIDAY", + 8: "WEATHER", + 9: "MAINTENANCE", + 10: "CONSTRUCTION", + 11: "POLICE_ACTIVITY", + 12: "MEDICAL_EMERGENCY", + } + Alert_Cause_value = map[string]int32{ + "UNKNOWN_CAUSE": 1, + "OTHER_CAUSE": 2, + "TECHNICAL_PROBLEM": 3, + "STRIKE": 4, + "DEMONSTRATION": 5, + "ACCIDENT": 6, + "HOLIDAY": 7, + "WEATHER": 8, + "MAINTENANCE": 9, + "CONSTRUCTION": 10, + "POLICE_ACTIVITY": 11, + "MEDICAL_EMERGENCY": 12, + } +) + +func (x Alert_Cause) Enum() *Alert_Cause { + p := new(Alert_Cause) + *p = x + return p +} + +func (x Alert_Cause) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Alert_Cause) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[5].Descriptor() +} + +func (Alert_Cause) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[5] +} + +func (x Alert_Cause) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *Alert_Cause) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = Alert_Cause(num) + return nil +} + +// Deprecated: Use Alert_Cause.Descriptor instead. +func (Alert_Cause) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{5, 0} +} + +// What is the effect of this problem on the affected entity. If effect_detail is included, then Effect must also be included. +type Alert_Effect int32 + +const ( + Alert_NO_SERVICE Alert_Effect = 1 + Alert_REDUCED_SERVICE Alert_Effect = 2 + // We don't care about INsignificant delays: they are hard to detect, have + // little impact on the user, and would clutter the results as they are too + // frequent. + Alert_SIGNIFICANT_DELAYS Alert_Effect = 3 + Alert_DETOUR Alert_Effect = 4 + Alert_ADDITIONAL_SERVICE Alert_Effect = 5 + Alert_MODIFIED_SERVICE Alert_Effect = 6 + Alert_OTHER_EFFECT Alert_Effect = 7 + Alert_UNKNOWN_EFFECT Alert_Effect = 8 + Alert_STOP_MOVED Alert_Effect = 9 + Alert_NO_EFFECT Alert_Effect = 10 + Alert_ACCESSIBILITY_ISSUE Alert_Effect = 11 +) + +// Enum value maps for Alert_Effect. +var ( + Alert_Effect_name = map[int32]string{ + 1: "NO_SERVICE", + 2: "REDUCED_SERVICE", + 3: "SIGNIFICANT_DELAYS", + 4: "DETOUR", + 5: "ADDITIONAL_SERVICE", + 6: "MODIFIED_SERVICE", + 7: "OTHER_EFFECT", + 8: "UNKNOWN_EFFECT", + 9: "STOP_MOVED", + 10: "NO_EFFECT", + 11: "ACCESSIBILITY_ISSUE", + } + Alert_Effect_value = map[string]int32{ + "NO_SERVICE": 1, + "REDUCED_SERVICE": 2, + "SIGNIFICANT_DELAYS": 3, + "DETOUR": 4, + "ADDITIONAL_SERVICE": 5, + "MODIFIED_SERVICE": 6, + "OTHER_EFFECT": 7, + "UNKNOWN_EFFECT": 8, + "STOP_MOVED": 9, + "NO_EFFECT": 10, + "ACCESSIBILITY_ISSUE": 11, + } +) + +func (x Alert_Effect) Enum() *Alert_Effect { + p := new(Alert_Effect) + *p = x + return p +} + +func (x Alert_Effect) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Alert_Effect) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[6].Descriptor() +} + +func (Alert_Effect) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[6] +} + +func (x Alert_Effect) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *Alert_Effect) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = Alert_Effect(num) + return nil +} + +// Deprecated: Use Alert_Effect.Descriptor instead. +func (Alert_Effect) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{5, 1} +} + +// Severity of this alert. +type Alert_SeverityLevel int32 + +const ( + Alert_UNKNOWN_SEVERITY Alert_SeverityLevel = 1 + Alert_INFO Alert_SeverityLevel = 2 + Alert_WARNING Alert_SeverityLevel = 3 + Alert_SEVERE Alert_SeverityLevel = 4 +) + +// Enum value maps for Alert_SeverityLevel. +var ( + Alert_SeverityLevel_name = map[int32]string{ + 1: "UNKNOWN_SEVERITY", + 2: "INFO", + 3: "WARNING", + 4: "SEVERE", + } + Alert_SeverityLevel_value = map[string]int32{ + "UNKNOWN_SEVERITY": 1, + "INFO": 2, + "WARNING": 3, + "SEVERE": 4, + } +) + +func (x Alert_SeverityLevel) Enum() *Alert_SeverityLevel { + p := new(Alert_SeverityLevel) + *p = x + return p +} + +func (x Alert_SeverityLevel) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Alert_SeverityLevel) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[7].Descriptor() +} + +func (Alert_SeverityLevel) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[7] +} + +func (x Alert_SeverityLevel) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *Alert_SeverityLevel) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = Alert_SeverityLevel(num) + return nil +} + +// Deprecated: Use Alert_SeverityLevel.Descriptor instead. +func (Alert_SeverityLevel) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{5, 2} +} + +// The relation between this trip and the static schedule. If a trip is done +// in accordance with temporary schedule, not reflected in GTFS, then it +// shouldn't be marked as SCHEDULED, but likely as ADDED. +type TripDescriptor_ScheduleRelationship int32 + +const ( + // Trip that is running in accordance with its GTFS schedule, or is close + // enough to the scheduled trip to be associated with it. + TripDescriptor_SCHEDULED TripDescriptor_ScheduleRelationship = 0 + // An extra trip that was added in addition to a running schedule, for + // example, to replace a broken vehicle or to respond to sudden passenger + // load. + // NOTE: Currently, behavior is unspecified for feeds that use this mode. There are discussions on the GTFS GitHub + // [(1)](https://github.com/google/transit/issues/106) [(2)](https://github.com/google/transit/pull/221) + // [(3)](https://github.com/google/transit/pull/219) around fully specifying or deprecating ADDED trips and the + // documentation will be updated when those discussions are finalized. + TripDescriptor_ADDED TripDescriptor_ScheduleRelationship = 1 + // A trip that is running with no schedule associated to it (GTFS frequencies.txt exact_times=0). + // Trips with ScheduleRelationship=UNSCHEDULED must also set all StopTimeUpdates.ScheduleRelationship=UNSCHEDULED. + TripDescriptor_UNSCHEDULED TripDescriptor_ScheduleRelationship = 2 + // A trip that existed in the schedule but was removed. + TripDescriptor_CANCELED TripDescriptor_ScheduleRelationship = 3 + // Should not be used - for backwards-compatibility only. + // + // Deprecated: Do not use. + TripDescriptor_REPLACEMENT TripDescriptor_ScheduleRelationship = 5 + // An extra trip that was added in addition to a running schedule, for example, to replace a broken vehicle or to + // respond to sudden passenger load. Used with TripUpdate.TripProperties.trip_id, TripUpdate.TripProperties.start_date, + // and TripUpdate.TripProperties.start_time to copy an existing trip from static GTFS but start at a different service + // date and/or time. Duplicating a trip is allowed if the service related to the original trip in (CSV) GTFS + // (in calendar.txt or calendar_dates.txt) is operating within the next 30 days. The trip to be duplicated is + // identified via TripUpdate.TripDescriptor.trip_id. This enumeration does not modify the existing trip referenced by + // TripUpdate.TripDescriptor.trip_id - if a producer wants to cancel the original trip, it must publish a separate + // TripUpdate with the value of CANCELED or DELETED. Trips defined in GTFS frequencies.txt with exact_times that is + // empty or equal to 0 cannot be duplicated. The VehiclePosition.TripDescriptor.trip_id for the new trip must contain + // the matching value from TripUpdate.TripProperties.trip_id and VehiclePosition.TripDescriptor.ScheduleRelationship + // must also be set to DUPLICATED. + // Existing producers and consumers that were using the ADDED enumeration to represent duplicated trips must follow + // the migration guide (https://github.com/google/transit/tree/master/gtfs-realtime/spec/en/examples/migration-duplicated.md) + // to transition to the DUPLICATED enumeration. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + TripDescriptor_DUPLICATED TripDescriptor_ScheduleRelationship = 6 + // A trip that existed in the schedule but was removed and must not be shown to users. + // DELETED should be used instead of CANCELED to indicate that a transit provider would like to entirely remove + // information about the corresponding trip from consuming applications, so the trip is not shown as cancelled to + // riders, e.g. a trip that is entirely being replaced by another trip. + // This designation becomes particularly important if several trips are cancelled and replaced with substitute service. + // If consumers were to show explicit information about the cancellations it would distract from the more important + // real-time predictions. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + TripDescriptor_DELETED TripDescriptor_ScheduleRelationship = 7 +) + +// Enum value maps for TripDescriptor_ScheduleRelationship. +var ( + TripDescriptor_ScheduleRelationship_name = map[int32]string{ + 0: "SCHEDULED", + 1: "ADDED", + 2: "UNSCHEDULED", + 3: "CANCELED", + 5: "REPLACEMENT", + 6: "DUPLICATED", + 7: "DELETED", + } + TripDescriptor_ScheduleRelationship_value = map[string]int32{ + "SCHEDULED": 0, + "ADDED": 1, + "UNSCHEDULED": 2, + "CANCELED": 3, + "REPLACEMENT": 5, + "DUPLICATED": 6, + "DELETED": 7, + } +) + +func (x TripDescriptor_ScheduleRelationship) Enum() *TripDescriptor_ScheduleRelationship { + p := new(TripDescriptor_ScheduleRelationship) + *p = x + return p +} + +func (x TripDescriptor_ScheduleRelationship) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (TripDescriptor_ScheduleRelationship) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[8].Descriptor() +} + +func (TripDescriptor_ScheduleRelationship) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[8] +} + +func (x TripDescriptor_ScheduleRelationship) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *TripDescriptor_ScheduleRelationship) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = TripDescriptor_ScheduleRelationship(num) + return nil +} + +// Deprecated: Use TripDescriptor_ScheduleRelationship.Descriptor instead. +func (TripDescriptor_ScheduleRelationship) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{8, 0} +} + +type VehicleDescriptor_WheelchairAccessible int32 + +const ( + // The trip doesn't have information about wheelchair accessibility. + // This is the **default** behavior. If the static GTFS contains a + // _wheelchair_accessible_ value, it won't be overwritten. + VehicleDescriptor_NO_VALUE VehicleDescriptor_WheelchairAccessible = 0 + // The trip has no accessibility value present. + // This value will overwrite the value from the GTFS. + VehicleDescriptor_UNKNOWN VehicleDescriptor_WheelchairAccessible = 1 + // The trip is wheelchair accessible. + // This value will overwrite the value from the GTFS. + VehicleDescriptor_WHEELCHAIR_ACCESSIBLE VehicleDescriptor_WheelchairAccessible = 2 + // The trip is **not** wheelchair accessible. + // This value will overwrite the value from the GTFS. + VehicleDescriptor_WHEELCHAIR_INACCESSIBLE VehicleDescriptor_WheelchairAccessible = 3 +) + +// Enum value maps for VehicleDescriptor_WheelchairAccessible. +var ( + VehicleDescriptor_WheelchairAccessible_name = map[int32]string{ + 0: "NO_VALUE", + 1: "UNKNOWN", + 2: "WHEELCHAIR_ACCESSIBLE", + 3: "WHEELCHAIR_INACCESSIBLE", + } + VehicleDescriptor_WheelchairAccessible_value = map[string]int32{ + "NO_VALUE": 0, + "UNKNOWN": 1, + "WHEELCHAIR_ACCESSIBLE": 2, + "WHEELCHAIR_INACCESSIBLE": 3, + } +) + +func (x VehicleDescriptor_WheelchairAccessible) Enum() *VehicleDescriptor_WheelchairAccessible { + p := new(VehicleDescriptor_WheelchairAccessible) + *p = x + return p +} + +func (x VehicleDescriptor_WheelchairAccessible) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (VehicleDescriptor_WheelchairAccessible) Descriptor() protoreflect.EnumDescriptor { + return file_gtfs_realtime_proto_enumTypes[9].Descriptor() +} + +func (VehicleDescriptor_WheelchairAccessible) Type() protoreflect.EnumType { + return &file_gtfs_realtime_proto_enumTypes[9] +} + +func (x VehicleDescriptor_WheelchairAccessible) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Do not use. +func (x *VehicleDescriptor_WheelchairAccessible) UnmarshalJSON(b []byte) error { + num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b) + if err != nil { + return err + } + *x = VehicleDescriptor_WheelchairAccessible(num) + return nil +} + +// Deprecated: Use VehicleDescriptor_WheelchairAccessible.Descriptor instead. +func (VehicleDescriptor_WheelchairAccessible) EnumDescriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{9, 0} +} + +// The contents of a feed message. +// A feed is a continuous stream of feed messages. Each message in the stream is +// obtained as a response to an appropriate HTTP GET request. +// A realtime feed is always defined with relation to an existing GTFS feed. +// All the entity ids are resolved with respect to the GTFS feed. +// Note that "required" and "optional" as stated in this file refer to Protocol +// Buffer cardinality, not semantic cardinality. See reference.md at +// https://github.com/google/transit/tree/master/gtfs-realtime for field +// semantic cardinality. +type FeedMessage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Metadata about this feed and feed message. + Header *FeedHeader `protobuf:"bytes,1,req,name=header" json:"header,omitempty"` + // Contents of the feed. + Entity []*FeedEntity `protobuf:"bytes,2,rep,name=entity" json:"entity,omitempty"` +} + +func (x *FeedMessage) Reset() { + *x = FeedMessage{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FeedMessage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FeedMessage) ProtoMessage() {} + +func (x *FeedMessage) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FeedMessage.ProtoReflect.Descriptor instead. +func (*FeedMessage) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{0} +} + +func (x *FeedMessage) GetHeader() *FeedHeader { + if x != nil { + return x.Header + } + return nil +} + +func (x *FeedMessage) GetEntity() []*FeedEntity { + if x != nil { + return x.Entity + } + return nil +} + +// Metadata about a feed, included in feed messages. +type FeedHeader struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Version of the feed specification. + // The current version is 2.0. Valid versions are "2.0", "1.0". + GtfsRealtimeVersion *string `protobuf:"bytes,1,req,name=gtfs_realtime_version,json=gtfsRealtimeVersion" json:"gtfs_realtime_version,omitempty"` + Incrementality *FeedHeader_Incrementality `protobuf:"varint,2,opt,name=incrementality,enum=transit_realtime.FeedHeader_Incrementality,def=0" json:"incrementality,omitempty"` + // This timestamp identifies the moment when the content of this feed has been + // created (in server time). In POSIX time (i.e., number of seconds since + // January 1st 1970 00:00:00 UTC). + Timestamp *uint64 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` +} + +// Default values for FeedHeader fields. +const ( + Default_FeedHeader_Incrementality = FeedHeader_FULL_DATASET +) + +func (x *FeedHeader) Reset() { + *x = FeedHeader{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FeedHeader) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FeedHeader) ProtoMessage() {} + +func (x *FeedHeader) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FeedHeader.ProtoReflect.Descriptor instead. +func (*FeedHeader) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{1} +} + +func (x *FeedHeader) GetGtfsRealtimeVersion() string { + if x != nil && x.GtfsRealtimeVersion != nil { + return *x.GtfsRealtimeVersion + } + return "" +} + +func (x *FeedHeader) GetIncrementality() FeedHeader_Incrementality { + if x != nil && x.Incrementality != nil { + return *x.Incrementality + } + return Default_FeedHeader_Incrementality +} + +func (x *FeedHeader) GetTimestamp() uint64 { + if x != nil && x.Timestamp != nil { + return *x.Timestamp + } + return 0 +} + +// A definition (or update) of an entity in the transit feed. +type FeedEntity struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // The ids are used only to provide incrementality support. The id should be + // unique within a FeedMessage. Consequent FeedMessages may contain + // FeedEntities with the same id. In case of a DIFFERENTIAL update the new + // FeedEntity with some id will replace the old FeedEntity with the same id + // (or delete it - see is_deleted below). + // The actual GTFS entities (e.g. stations, routes, trips) referenced by the + // feed must be specified by explicit selectors (see EntitySelector below for + // more info). + Id *string `protobuf:"bytes,1,req,name=id" json:"id,omitempty"` + // Whether this entity is to be deleted. Relevant only for incremental + // fetches. + IsDeleted *bool `protobuf:"varint,2,opt,name=is_deleted,json=isDeleted,def=0" json:"is_deleted,omitempty"` + // Data about the entity itself. Exactly one of the following fields must be + // present (unless the entity is being deleted). + TripUpdate *TripUpdate `protobuf:"bytes,3,opt,name=trip_update,json=tripUpdate" json:"trip_update,omitempty"` + Vehicle *VehiclePosition `protobuf:"bytes,4,opt,name=vehicle" json:"vehicle,omitempty"` + Alert *Alert `protobuf:"bytes,5,opt,name=alert" json:"alert,omitempty"` + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + Shape *Shape `protobuf:"bytes,6,opt,name=shape" json:"shape,omitempty"` +} + +// Default values for FeedEntity fields. +const ( + Default_FeedEntity_IsDeleted = bool(false) +) + +func (x *FeedEntity) Reset() { + *x = FeedEntity{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FeedEntity) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FeedEntity) ProtoMessage() {} + +func (x *FeedEntity) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FeedEntity.ProtoReflect.Descriptor instead. +func (*FeedEntity) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{2} +} + +func (x *FeedEntity) GetId() string { + if x != nil && x.Id != nil { + return *x.Id + } + return "" +} + +func (x *FeedEntity) GetIsDeleted() bool { + if x != nil && x.IsDeleted != nil { + return *x.IsDeleted + } + return Default_FeedEntity_IsDeleted +} + +func (x *FeedEntity) GetTripUpdate() *TripUpdate { + if x != nil { + return x.TripUpdate + } + return nil +} + +func (x *FeedEntity) GetVehicle() *VehiclePosition { + if x != nil { + return x.Vehicle + } + return nil +} + +func (x *FeedEntity) GetAlert() *Alert { + if x != nil { + return x.Alert + } + return nil +} + +func (x *FeedEntity) GetShape() *Shape { + if x != nil { + return x.Shape + } + return nil +} + +// Realtime update of the progress of a vehicle along a trip. +// Depending on the value of ScheduleRelationship, a TripUpdate can specify: +// - A trip that proceeds along the schedule. +// - A trip that proceeds along a route but has no fixed schedule. +// - A trip that have been added or removed with regard to schedule. +// +// The updates can be for future, predicted arrival/departure events, or for +// past events that already occurred. +// Normally, updates should get more precise and more certain (see +// uncertainty below) as the events gets closer to current time. +// Even if that is not possible, the information for past events should be +// precise and certain. In particular, if an update points to time in the past +// but its update's uncertainty is not 0, the client should conclude that the +// update is a (wrong) prediction and that the trip has not completed yet. +// +// Note that the update can describe a trip that is already completed. +// To this end, it is enough to provide an update for the last stop of the trip. +// If the time of that is in the past, the client will conclude from that that +// the whole trip is in the past (it is possible, although inconsequential, to +// also provide updates for preceding stops). +// This option is most relevant for a trip that has completed ahead of schedule, +// but according to the schedule, the trip is still proceeding at the current +// time. Removing the updates for this trip could make the client assume +// that the trip is still proceeding. +// Note that the feed provider is allowed, but not required, to purge past +// updates - this is one case where this would be practically useful. +type TripUpdate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // The Trip that this message applies to. There can be at most one + // TripUpdate entity for each actual trip instance. + // If there is none, that means there is no prediction information available. + // It does *not* mean that the trip is progressing according to schedule. + Trip *TripDescriptor `protobuf:"bytes,1,req,name=trip" json:"trip,omitempty"` + // Additional information on the vehicle that is serving this trip. + Vehicle *VehicleDescriptor `protobuf:"bytes,3,opt,name=vehicle" json:"vehicle,omitempty"` + // Updates to StopTimes for the trip (both future, i.e., predictions, and in + // some cases, past ones, i.e., those that already happened). + // The updates must be sorted by stop_sequence, and apply for all the + // following stops of the trip up to the next specified one. + // + // Example 1: + // For a trip with 20 stops, a StopTimeUpdate with arrival delay and departure + // delay of 0 for stop_sequence of the current stop means that the trip is + // exactly on time. + // + // Example 2: + // For the same trip instance, 3 StopTimeUpdates are provided: + // - delay of 5 min for stop_sequence 3 + // - delay of 1 min for stop_sequence 8 + // - delay of unspecified duration for stop_sequence 10 + // This will be interpreted as: + // - stop_sequences 3,4,5,6,7 have delay of 5 min. + // - stop_sequences 8,9 have delay of 1 min. + // - stop_sequences 10,... have unknown delay. + StopTimeUpdate []*TripUpdate_StopTimeUpdate `protobuf:"bytes,2,rep,name=stop_time_update,json=stopTimeUpdate" json:"stop_time_update,omitempty"` + // The most recent moment at which the vehicle's real-time progress was measured + // to estimate StopTimes in the future. When StopTimes in the past are provided, + // arrival/departure times may be earlier than this value. In POSIX + // time (i.e., the number of seconds since January 1st 1970 00:00:00 UTC). + Timestamp *uint64 `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"` + // The current schedule deviation for the trip. Delay should only be + // specified when the prediction is given relative to some existing schedule + // in GTFS. + // + // Delay (in seconds) can be positive (meaning that the vehicle is late) or + // negative (meaning that the vehicle is ahead of schedule). Delay of 0 + // means that the vehicle is exactly on time. + // + // Delay information in StopTimeUpdates take precedent of trip-level delay + // information, such that trip-level delay is only propagated until the next + // stop along the trip with a StopTimeUpdate delay value specified. + // + // Feed providers are strongly encouraged to provide a TripUpdate.timestamp + // value indicating when the delay value was last updated, in order to + // evaluate the freshness of the data. + // + // NOTE: This field is still experimental, and subject to change. It may be + // formally adopted in the future. + Delay *int32 `protobuf:"varint,5,opt,name=delay" json:"delay,omitempty"` + TripProperties *TripUpdate_TripProperties `protobuf:"bytes,6,opt,name=trip_properties,json=tripProperties" json:"trip_properties,omitempty"` +} + +func (x *TripUpdate) Reset() { + *x = TripUpdate{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TripUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TripUpdate) ProtoMessage() {} + +func (x *TripUpdate) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TripUpdate.ProtoReflect.Descriptor instead. +func (*TripUpdate) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{3} +} + +func (x *TripUpdate) GetTrip() *TripDescriptor { + if x != nil { + return x.Trip + } + return nil +} + +func (x *TripUpdate) GetVehicle() *VehicleDescriptor { + if x != nil { + return x.Vehicle + } + return nil +} + +func (x *TripUpdate) GetStopTimeUpdate() []*TripUpdate_StopTimeUpdate { + if x != nil { + return x.StopTimeUpdate + } + return nil +} + +func (x *TripUpdate) GetTimestamp() uint64 { + if x != nil && x.Timestamp != nil { + return *x.Timestamp + } + return 0 +} + +func (x *TripUpdate) GetDelay() int32 { + if x != nil && x.Delay != nil { + return *x.Delay + } + return 0 +} + +func (x *TripUpdate) GetTripProperties() *TripUpdate_TripProperties { + if x != nil { + return x.TripProperties + } + return nil +} + +// Realtime positioning information for a given vehicle. +type VehiclePosition struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // The Trip that this vehicle is serving. + // Can be empty or partial if the vehicle can not be identified with a given + // trip instance. + Trip *TripDescriptor `protobuf:"bytes,1,opt,name=trip" json:"trip,omitempty"` + // Additional information on the vehicle that is serving this trip. + Vehicle *VehicleDescriptor `protobuf:"bytes,8,opt,name=vehicle" json:"vehicle,omitempty"` + // Current position of this vehicle. + Position *Position `protobuf:"bytes,2,opt,name=position" json:"position,omitempty"` + // The stop sequence index of the current stop. The meaning of + // current_stop_sequence (i.e., the stop that it refers to) is determined by + // current_status. + // If current_status is missing IN_TRANSIT_TO is assumed. + CurrentStopSequence *uint32 `protobuf:"varint,3,opt,name=current_stop_sequence,json=currentStopSequence" json:"current_stop_sequence,omitempty"` + // Identifies the current stop. The value must be the same as in stops.txt in + // the corresponding GTFS feed. + StopId *string `protobuf:"bytes,7,opt,name=stop_id,json=stopId" json:"stop_id,omitempty"` + // The exact status of the vehicle with respect to the current stop. + // Ignored if current_stop_sequence is missing. + CurrentStatus *VehiclePosition_VehicleStopStatus `protobuf:"varint,4,opt,name=current_status,json=currentStatus,enum=transit_realtime.VehiclePosition_VehicleStopStatus,def=2" json:"current_status,omitempty"` + // Moment at which the vehicle's position was measured. In POSIX time + // (i.e., number of seconds since January 1st 1970 00:00:00 UTC). + Timestamp *uint64 `protobuf:"varint,5,opt,name=timestamp" json:"timestamp,omitempty"` + CongestionLevel *VehiclePosition_CongestionLevel `protobuf:"varint,6,opt,name=congestion_level,json=congestionLevel,enum=transit_realtime.VehiclePosition_CongestionLevel" json:"congestion_level,omitempty"` + // If multi_carriage_status is populated with per-carriage OccupancyStatus, + // then this field should describe the entire vehicle with all carriages accepting passengers considered. + OccupancyStatus *VehiclePosition_OccupancyStatus `protobuf:"varint,9,opt,name=occupancy_status,json=occupancyStatus,enum=transit_realtime.VehiclePosition_OccupancyStatus" json:"occupancy_status,omitempty"` + // A percentage value indicating the degree of passenger occupancy in the vehicle. + // The values are represented as an integer without decimals. 0 means 0% and 100 means 100%. + // The value 100 should represent the total maximum occupancy the vehicle was designed for, + // including both seated and standing capacity, and current operating regulations allow. + // The value may exceed 100 if there are more passengers than the maximum designed capacity. + // The precision of occupancy_percentage should be low enough that individual passengers cannot be tracked boarding or alighting the vehicle. + // If multi_carriage_status is populated with per-carriage occupancy_percentage, + // then this field should describe the entire vehicle with all carriages accepting passengers considered. + // This field is still experimental, and subject to change. It may be formally adopted in the future. + OccupancyPercentage *uint32 `protobuf:"varint,10,opt,name=occupancy_percentage,json=occupancyPercentage" json:"occupancy_percentage,omitempty"` + // Details of the multiple carriages of this given vehicle. + // The first occurrence represents the first carriage of the vehicle, + // given the current direction of travel. + // The number of occurrences of the multi_carriage_details + // field represents the number of carriages of the vehicle. + // It also includes non boardable carriages, + // like engines, maintenance carriages, etc… as they provide valuable + // information to passengers about where to stand on a platform. + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + MultiCarriageDetails []*VehiclePosition_CarriageDetails `protobuf:"bytes,11,rep,name=multi_carriage_details,json=multiCarriageDetails" json:"multi_carriage_details,omitempty"` +} + +// Default values for VehiclePosition fields. +const ( + Default_VehiclePosition_CurrentStatus = VehiclePosition_IN_TRANSIT_TO +) + +func (x *VehiclePosition) Reset() { + *x = VehiclePosition{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VehiclePosition) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VehiclePosition) ProtoMessage() {} + +func (x *VehiclePosition) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VehiclePosition.ProtoReflect.Descriptor instead. +func (*VehiclePosition) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{4} +} + +func (x *VehiclePosition) GetTrip() *TripDescriptor { + if x != nil { + return x.Trip + } + return nil +} + +func (x *VehiclePosition) GetVehicle() *VehicleDescriptor { + if x != nil { + return x.Vehicle + } + return nil +} + +func (x *VehiclePosition) GetPosition() *Position { + if x != nil { + return x.Position + } + return nil +} + +func (x *VehiclePosition) GetCurrentStopSequence() uint32 { + if x != nil && x.CurrentStopSequence != nil { + return *x.CurrentStopSequence + } + return 0 +} + +func (x *VehiclePosition) GetStopId() string { + if x != nil && x.StopId != nil { + return *x.StopId + } + return "" +} + +func (x *VehiclePosition) GetCurrentStatus() VehiclePosition_VehicleStopStatus { + if x != nil && x.CurrentStatus != nil { + return *x.CurrentStatus + } + return Default_VehiclePosition_CurrentStatus +} + +func (x *VehiclePosition) GetTimestamp() uint64 { + if x != nil && x.Timestamp != nil { + return *x.Timestamp + } + return 0 +} + +func (x *VehiclePosition) GetCongestionLevel() VehiclePosition_CongestionLevel { + if x != nil && x.CongestionLevel != nil { + return *x.CongestionLevel + } + return VehiclePosition_UNKNOWN_CONGESTION_LEVEL +} + +func (x *VehiclePosition) GetOccupancyStatus() VehiclePosition_OccupancyStatus { + if x != nil && x.OccupancyStatus != nil { + return *x.OccupancyStatus + } + return VehiclePosition_EMPTY +} + +func (x *VehiclePosition) GetOccupancyPercentage() uint32 { + if x != nil && x.OccupancyPercentage != nil { + return *x.OccupancyPercentage + } + return 0 +} + +func (x *VehiclePosition) GetMultiCarriageDetails() []*VehiclePosition_CarriageDetails { + if x != nil { + return x.MultiCarriageDetails + } + return nil +} + +// An alert, indicating some sort of incident in the public transit network. +type Alert struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Time when the alert should be shown to the user. If missing, the + // alert will be shown as long as it appears in the feed. + // If multiple ranges are given, the alert will be shown during all of them. + ActivePeriod []*TimeRange `protobuf:"bytes,1,rep,name=active_period,json=activePeriod" json:"active_period,omitempty"` + // Entities whose users we should notify of this alert. + InformedEntity []*EntitySelector `protobuf:"bytes,5,rep,name=informed_entity,json=informedEntity" json:"informed_entity,omitempty"` + Cause *Alert_Cause `protobuf:"varint,6,opt,name=cause,enum=transit_realtime.Alert_Cause,def=1" json:"cause,omitempty"` + Effect *Alert_Effect `protobuf:"varint,7,opt,name=effect,enum=transit_realtime.Alert_Effect,def=8" json:"effect,omitempty"` + // The URL which provides additional information about the alert. + Url *TranslatedString `protobuf:"bytes,8,opt,name=url" json:"url,omitempty"` + // Alert header. Contains a short summary of the alert text as plain-text. + HeaderText *TranslatedString `protobuf:"bytes,10,opt,name=header_text,json=headerText" json:"header_text,omitempty"` + // Full description for the alert as plain-text. The information in the + // description should add to the information of the header. + DescriptionText *TranslatedString `protobuf:"bytes,11,opt,name=description_text,json=descriptionText" json:"description_text,omitempty"` + // Text for alert header to be used in text-to-speech implementations. This field is the text-to-speech version of header_text. + TtsHeaderText *TranslatedString `protobuf:"bytes,12,opt,name=tts_header_text,json=ttsHeaderText" json:"tts_header_text,omitempty"` + // Text for full description for the alert to be used in text-to-speech implementations. This field is the text-to-speech version of description_text. + TtsDescriptionText *TranslatedString `protobuf:"bytes,13,opt,name=tts_description_text,json=ttsDescriptionText" json:"tts_description_text,omitempty"` + SeverityLevel *Alert_SeverityLevel `protobuf:"varint,14,opt,name=severity_level,json=severityLevel,enum=transit_realtime.Alert_SeverityLevel,def=1" json:"severity_level,omitempty"` + // TranslatedImage to be displayed along the alert text. Used to explain visually the alert effect of a detour, station closure, etc. The image must enhance the understanding of the alert. Any essential information communicated within the image must also be contained in the alert text. + // The following types of images are discouraged : image containing mainly text, marketing or branded images that add no additional information. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + Image *TranslatedImage `protobuf:"bytes,15,opt,name=image" json:"image,omitempty"` + // Text describing the appearance of the linked image in the `image` field (e.g., in case the image can't be displayed + // or the user can't see the image for accessibility reasons). See the HTML spec for alt image text - https://html.spec.whatwg.org/#alt. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + ImageAlternativeText *TranslatedString `protobuf:"bytes,16,opt,name=image_alternative_text,json=imageAlternativeText" json:"image_alternative_text,omitempty"` + // Description of the cause of the alert that allows for agency-specific language; more specific than the Cause. If cause_detail is included, then Cause must also be included. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + CauseDetail *TranslatedString `protobuf:"bytes,17,opt,name=cause_detail,json=causeDetail" json:"cause_detail,omitempty"` + // Description of the effect of the alert that allows for agency-specific language; more specific than the Effect. If effect_detail is included, then Effect must also be included. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + EffectDetail *TranslatedString `protobuf:"bytes,18,opt,name=effect_detail,json=effectDetail" json:"effect_detail,omitempty"` +} + +// Default values for Alert fields. +const ( + Default_Alert_Cause = Alert_UNKNOWN_CAUSE + Default_Alert_Effect = Alert_UNKNOWN_EFFECT + Default_Alert_SeverityLevel = Alert_UNKNOWN_SEVERITY +) + +func (x *Alert) Reset() { + *x = Alert{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Alert) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Alert) ProtoMessage() {} + +func (x *Alert) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Alert.ProtoReflect.Descriptor instead. +func (*Alert) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{5} +} + +func (x *Alert) GetActivePeriod() []*TimeRange { + if x != nil { + return x.ActivePeriod + } + return nil +} + +func (x *Alert) GetInformedEntity() []*EntitySelector { + if x != nil { + return x.InformedEntity + } + return nil +} + +func (x *Alert) GetCause() Alert_Cause { + if x != nil && x.Cause != nil { + return *x.Cause + } + return Default_Alert_Cause +} + +func (x *Alert) GetEffect() Alert_Effect { + if x != nil && x.Effect != nil { + return *x.Effect + } + return Default_Alert_Effect +} + +func (x *Alert) GetUrl() *TranslatedString { + if x != nil { + return x.Url + } + return nil +} + +func (x *Alert) GetHeaderText() *TranslatedString { + if x != nil { + return x.HeaderText + } + return nil +} + +func (x *Alert) GetDescriptionText() *TranslatedString { + if x != nil { + return x.DescriptionText + } + return nil +} + +func (x *Alert) GetTtsHeaderText() *TranslatedString { + if x != nil { + return x.TtsHeaderText + } + return nil +} + +func (x *Alert) GetTtsDescriptionText() *TranslatedString { + if x != nil { + return x.TtsDescriptionText + } + return nil +} + +func (x *Alert) GetSeverityLevel() Alert_SeverityLevel { + if x != nil && x.SeverityLevel != nil { + return *x.SeverityLevel + } + return Default_Alert_SeverityLevel +} + +func (x *Alert) GetImage() *TranslatedImage { + if x != nil { + return x.Image + } + return nil +} + +func (x *Alert) GetImageAlternativeText() *TranslatedString { + if x != nil { + return x.ImageAlternativeText + } + return nil +} + +func (x *Alert) GetCauseDetail() *TranslatedString { + if x != nil { + return x.CauseDetail + } + return nil +} + +func (x *Alert) GetEffectDetail() *TranslatedString { + if x != nil { + return x.EffectDetail + } + return nil +} + +// A time interval. The interval is considered active at time 't' if 't' is +// greater than or equal to the start time and less than the end time. +type TimeRange struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Start time, in POSIX time (i.e., number of seconds since January 1st 1970 + // 00:00:00 UTC). + // If missing, the interval starts at minus infinity. + Start *uint64 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"` + // End time, in POSIX time (i.e., number of seconds since January 1st 1970 + // 00:00:00 UTC). + // If missing, the interval ends at plus infinity. + End *uint64 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"` +} + +func (x *TimeRange) Reset() { + *x = TimeRange{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TimeRange) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TimeRange) ProtoMessage() {} + +func (x *TimeRange) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TimeRange.ProtoReflect.Descriptor instead. +func (*TimeRange) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{6} +} + +func (x *TimeRange) GetStart() uint64 { + if x != nil && x.Start != nil { + return *x.Start + } + return 0 +} + +func (x *TimeRange) GetEnd() uint64 { + if x != nil && x.End != nil { + return *x.End + } + return 0 +} + +// A position. +type Position struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Degrees North, in the WGS-84 coordinate system. + Latitude *float32 `protobuf:"fixed32,1,req,name=latitude" json:"latitude,omitempty"` + // Degrees East, in the WGS-84 coordinate system. + Longitude *float32 `protobuf:"fixed32,2,req,name=longitude" json:"longitude,omitempty"` + // Bearing, in degrees, clockwise from North, i.e., 0 is North and 90 is East. + // This can be the compass bearing, or the direction towards the next stop + // or intermediate location. + // This should not be direction deduced from the sequence of previous + // positions, which can be computed from previous data. + Bearing *float32 `protobuf:"fixed32,3,opt,name=bearing" json:"bearing,omitempty"` + // Odometer value, in meters. + Odometer *float64 `protobuf:"fixed64,4,opt,name=odometer" json:"odometer,omitempty"` + // Momentary speed measured by the vehicle, in meters per second. + Speed *float32 `protobuf:"fixed32,5,opt,name=speed" json:"speed,omitempty"` +} + +func (x *Position) Reset() { + *x = Position{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Position) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Position) ProtoMessage() {} + +func (x *Position) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Position.ProtoReflect.Descriptor instead. +func (*Position) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{7} +} + +func (x *Position) GetLatitude() float32 { + if x != nil && x.Latitude != nil { + return *x.Latitude + } + return 0 +} + +func (x *Position) GetLongitude() float32 { + if x != nil && x.Longitude != nil { + return *x.Longitude + } + return 0 +} + +func (x *Position) GetBearing() float32 { + if x != nil && x.Bearing != nil { + return *x.Bearing + } + return 0 +} + +func (x *Position) GetOdometer() float64 { + if x != nil && x.Odometer != nil { + return *x.Odometer + } + return 0 +} + +func (x *Position) GetSpeed() float32 { + if x != nil && x.Speed != nil { + return *x.Speed + } + return 0 +} + +// A descriptor that identifies an instance of a GTFS trip, or all instances of +// a trip along a route. +// - To specify a single trip instance, the trip_id (and if necessary, +// start_time) is set. If route_id is also set, then it should be same as one +// that the given trip corresponds to. +// - To specify all the trips along a given route, only the route_id should be +// set. Note that if the trip_id is not known, then stop sequence ids in +// TripUpdate are not sufficient, and stop_ids must be provided as well. In +// addition, absolute arrival/departure times must be provided. +type TripDescriptor struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // The trip_id from the GTFS feed that this selector refers to. + // For non frequency-based trips, this field is enough to uniquely identify + // the trip. For frequency-based trip, start_time and start_date might also be + // necessary. When schedule_relationship is DUPLICATED within a TripUpdate, the trip_id identifies the trip from + // static GTFS to be duplicated. When schedule_relationship is DUPLICATED within a VehiclePosition, the trip_id + // identifies the new duplicate trip and must contain the value for the corresponding TripUpdate.TripProperties.trip_id. + TripId *string `protobuf:"bytes,1,opt,name=trip_id,json=tripId" json:"trip_id,omitempty"` + // The route_id from the GTFS that this selector refers to. + RouteId *string `protobuf:"bytes,5,opt,name=route_id,json=routeId" json:"route_id,omitempty"` + // The direction_id from the GTFS feed trips.txt file, indicating the + // direction of travel for trips this selector refers to. + DirectionId *uint32 `protobuf:"varint,6,opt,name=direction_id,json=directionId" json:"direction_id,omitempty"` + // The initially scheduled start time of this trip instance. + // When the trip_id corresponds to a non-frequency-based trip, this field + // should either be omitted or be equal to the value in the GTFS feed. When + // the trip_id correponds to a frequency-based trip, the start_time must be + // specified for trip updates and vehicle positions. If the trip corresponds + // to exact_times=1 GTFS record, then start_time must be some multiple + // (including zero) of headway_secs later than frequencies.txt start_time for + // the corresponding time period. If the trip corresponds to exact_times=0, + // then its start_time may be arbitrary, and is initially expected to be the + // first departure of the trip. Once established, the start_time of this + // frequency-based trip should be considered immutable, even if the first + // departure time changes -- that time change may instead be reflected in a + // StopTimeUpdate. + // Format and semantics of the field is same as that of + // GTFS/frequencies.txt/start_time, e.g., 11:15:35 or 25:15:35. + StartTime *string `protobuf:"bytes,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"` + // The scheduled start date of this trip instance. + // Must be provided to disambiguate trips that are so late as to collide with + // a scheduled trip on a next day. For example, for a train that departs 8:00 + // and 20:00 every day, and is 12 hours late, there would be two distinct + // trips on the same time. + // This field can be provided but is not mandatory for schedules in which such + // collisions are impossible - for example, a service running on hourly + // schedule where a vehicle that is one hour late is not considered to be + // related to schedule anymore. + // In YYYYMMDD format. + StartDate *string `protobuf:"bytes,3,opt,name=start_date,json=startDate" json:"start_date,omitempty"` + ScheduleRelationship *TripDescriptor_ScheduleRelationship `protobuf:"varint,4,opt,name=schedule_relationship,json=scheduleRelationship,enum=transit_realtime.TripDescriptor_ScheduleRelationship" json:"schedule_relationship,omitempty"` +} + +func (x *TripDescriptor) Reset() { + *x = TripDescriptor{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TripDescriptor) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TripDescriptor) ProtoMessage() {} + +func (x *TripDescriptor) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TripDescriptor.ProtoReflect.Descriptor instead. +func (*TripDescriptor) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{8} +} + +func (x *TripDescriptor) GetTripId() string { + if x != nil && x.TripId != nil { + return *x.TripId + } + return "" +} + +func (x *TripDescriptor) GetRouteId() string { + if x != nil && x.RouteId != nil { + return *x.RouteId + } + return "" +} + +func (x *TripDescriptor) GetDirectionId() uint32 { + if x != nil && x.DirectionId != nil { + return *x.DirectionId + } + return 0 +} + +func (x *TripDescriptor) GetStartTime() string { + if x != nil && x.StartTime != nil { + return *x.StartTime + } + return "" +} + +func (x *TripDescriptor) GetStartDate() string { + if x != nil && x.StartDate != nil { + return *x.StartDate + } + return "" +} + +func (x *TripDescriptor) GetScheduleRelationship() TripDescriptor_ScheduleRelationship { + if x != nil && x.ScheduleRelationship != nil { + return *x.ScheduleRelationship + } + return TripDescriptor_SCHEDULED +} + +// Identification information for the vehicle performing the trip. +type VehicleDescriptor struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Internal system identification of the vehicle. Should be unique per + // vehicle, and can be used for tracking the vehicle as it proceeds through + // the system. + Id *string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + // User visible label, i.e., something that must be shown to the passenger to + // help identify the correct vehicle. + Label *string `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"` + // The license plate of the vehicle. + LicensePlate *string `protobuf:"bytes,3,opt,name=license_plate,json=licensePlate" json:"license_plate,omitempty"` + WheelchairAccessible *VehicleDescriptor_WheelchairAccessible `protobuf:"varint,4,opt,name=wheelchair_accessible,json=wheelchairAccessible,enum=transit_realtime.VehicleDescriptor_WheelchairAccessible,def=0" json:"wheelchair_accessible,omitempty"` +} + +// Default values for VehicleDescriptor fields. +const ( + Default_VehicleDescriptor_WheelchairAccessible = VehicleDescriptor_NO_VALUE +) + +func (x *VehicleDescriptor) Reset() { + *x = VehicleDescriptor{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VehicleDescriptor) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VehicleDescriptor) ProtoMessage() {} + +func (x *VehicleDescriptor) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VehicleDescriptor.ProtoReflect.Descriptor instead. +func (*VehicleDescriptor) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{9} +} + +func (x *VehicleDescriptor) GetId() string { + if x != nil && x.Id != nil { + return *x.Id + } + return "" +} + +func (x *VehicleDescriptor) GetLabel() string { + if x != nil && x.Label != nil { + return *x.Label + } + return "" +} + +func (x *VehicleDescriptor) GetLicensePlate() string { + if x != nil && x.LicensePlate != nil { + return *x.LicensePlate + } + return "" +} + +func (x *VehicleDescriptor) GetWheelchairAccessible() VehicleDescriptor_WheelchairAccessible { + if x != nil && x.WheelchairAccessible != nil { + return *x.WheelchairAccessible + } + return Default_VehicleDescriptor_WheelchairAccessible +} + +// A selector for an entity in a GTFS feed. +type EntitySelector struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // The values of the fields should correspond to the appropriate fields in the + // GTFS feed. + // At least one specifier must be given. If several are given, then the + // matching has to apply to all the given specifiers. + AgencyId *string `protobuf:"bytes,1,opt,name=agency_id,json=agencyId" json:"agency_id,omitempty"` + RouteId *string `protobuf:"bytes,2,opt,name=route_id,json=routeId" json:"route_id,omitempty"` + // corresponds to route_type in GTFS. + RouteType *int32 `protobuf:"varint,3,opt,name=route_type,json=routeType" json:"route_type,omitempty"` + Trip *TripDescriptor `protobuf:"bytes,4,opt,name=trip" json:"trip,omitempty"` + StopId *string `protobuf:"bytes,5,opt,name=stop_id,json=stopId" json:"stop_id,omitempty"` + // Corresponds to trip direction_id in GTFS trips.txt. If provided the + // route_id must also be provided. + DirectionId *uint32 `protobuf:"varint,6,opt,name=direction_id,json=directionId" json:"direction_id,omitempty"` +} + +func (x *EntitySelector) Reset() { + *x = EntitySelector{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *EntitySelector) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EntitySelector) ProtoMessage() {} + +func (x *EntitySelector) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EntitySelector.ProtoReflect.Descriptor instead. +func (*EntitySelector) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{10} +} + +func (x *EntitySelector) GetAgencyId() string { + if x != nil && x.AgencyId != nil { + return *x.AgencyId + } + return "" +} + +func (x *EntitySelector) GetRouteId() string { + if x != nil && x.RouteId != nil { + return *x.RouteId + } + return "" +} + +func (x *EntitySelector) GetRouteType() int32 { + if x != nil && x.RouteType != nil { + return *x.RouteType + } + return 0 +} + +func (x *EntitySelector) GetTrip() *TripDescriptor { + if x != nil { + return x.Trip + } + return nil +} + +func (x *EntitySelector) GetStopId() string { + if x != nil && x.StopId != nil { + return *x.StopId + } + return "" +} + +func (x *EntitySelector) GetDirectionId() uint32 { + if x != nil && x.DirectionId != nil { + return *x.DirectionId + } + return 0 +} + +// An internationalized message containing per-language versions of a snippet of +// text or a URL. +// One of the strings from a message will be picked up. The resolution proceeds +// as follows: +// 1. If the UI language matches the language code of a translation, +// the first matching translation is picked. +// 2. If a default UI language (e.g., English) matches the language code of a +// translation, the first matching translation is picked. +// 3. If some translation has an unspecified language code, that translation is +// picked. +type TranslatedString struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // At least one translation must be provided. + Translation []*TranslatedString_Translation `protobuf:"bytes,1,rep,name=translation" json:"translation,omitempty"` +} + +func (x *TranslatedString) Reset() { + *x = TranslatedString{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TranslatedString) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TranslatedString) ProtoMessage() {} + +func (x *TranslatedString) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TranslatedString.ProtoReflect.Descriptor instead. +func (*TranslatedString) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{11} +} + +func (x *TranslatedString) GetTranslation() []*TranslatedString_Translation { + if x != nil { + return x.Translation + } + return nil +} + +// An internationalized image containing per-language versions of a URL linking to an image +// along with meta information +// Only one of the images from a message will be retained by consumers. The resolution proceeds +// as follows: +// 1. If the UI language matches the language code of a translation, +// the first matching translation is picked. +// 2. If a default UI language (e.g., English) matches the language code of a +// translation, the first matching translation is picked. +// 3. If some translation has an unspecified language code, that translation is +// picked. +// +// NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. +type TranslatedImage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // At least one localized image must be provided. + LocalizedImage []*TranslatedImage_LocalizedImage `protobuf:"bytes,1,rep,name=localized_image,json=localizedImage" json:"localized_image,omitempty"` +} + +func (x *TranslatedImage) Reset() { + *x = TranslatedImage{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TranslatedImage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TranslatedImage) ProtoMessage() {} + +func (x *TranslatedImage) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TranslatedImage.ProtoReflect.Descriptor instead. +func (*TranslatedImage) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{12} +} + +func (x *TranslatedImage) GetLocalizedImage() []*TranslatedImage_LocalizedImage { + if x != nil { + return x.LocalizedImage + } + return nil +} + +// Describes the physical path that a vehicle takes when it's not part of the (CSV) GTFS, +// such as for a detour. Shapes belong to Trips, and consist of a sequence of shape points. +// Tracing the points in order provides the path of the vehicle. Shapes do not need to intercept +// the location of Stops exactly, but all Stops on a trip should lie within a small distance of +// the shape for that trip, i.e. close to straight line segments connecting the shape points +// NOTE: This message is still experimental, and subject to change. It may be formally adopted in the future. +type Shape struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Identifier of the shape. Must be different than any shape_id defined in the (CSV) GTFS. + // This field is required as per reference.md, but needs to be specified here optional because "Required is Forever" + // See https://developers.google.com/protocol-buffers/docs/proto#specifying_field_rules + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + ShapeId *string `protobuf:"bytes,1,opt,name=shape_id,json=shapeId" json:"shape_id,omitempty"` + // Encoded polyline representation of the shape. This polyline must contain at least two points. + // For more information about encoded polylines, see https://developers.google.com/maps/documentation/utilities/polylinealgorithm + // This field is required as per reference.md, but needs to be specified here optional because "Required is Forever" + // See https://developers.google.com/protocol-buffers/docs/proto#specifying_field_rules + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + EncodedPolyline *string `protobuf:"bytes,2,opt,name=encoded_polyline,json=encodedPolyline" json:"encoded_polyline,omitempty"` +} + +func (x *Shape) Reset() { + *x = Shape{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Shape) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Shape) ProtoMessage() {} + +func (x *Shape) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Shape.ProtoReflect.Descriptor instead. +func (*Shape) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{13} +} + +func (x *Shape) GetShapeId() string { + if x != nil && x.ShapeId != nil { + return *x.ShapeId + } + return "" +} + +func (x *Shape) GetEncodedPolyline() string { + if x != nil && x.EncodedPolyline != nil { + return *x.EncodedPolyline + } + return "" +} + +// Timing information for a single predicted event (either arrival or +// departure). +// Timing consists of delay and/or estimated time, and uncertainty. +// - delay should be used when the prediction is given relative to some +// existing schedule in GTFS. +// - time should be given whether there is a predicted schedule or not. If +// both time and delay are specified, time will take precedence +// (although normally, time, if given for a scheduled trip, should be +// equal to scheduled time in GTFS + delay). +// +// Uncertainty applies equally to both time and delay. +// The uncertainty roughly specifies the expected error in true delay (but +// note, we don't yet define its precise statistical meaning). It's possible +// for the uncertainty to be 0, for example for trains that are driven under +// computer timing control. +type TripUpdate_StopTimeEvent struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Delay (in seconds) can be positive (meaning that the vehicle is late) or + // negative (meaning that the vehicle is ahead of schedule). Delay of 0 + // means that the vehicle is exactly on time. + Delay *int32 `protobuf:"varint,1,opt,name=delay" json:"delay,omitempty"` + // Event as absolute time. + // In Unix time (i.e., number of seconds since January 1st 1970 00:00:00 + // UTC). + Time *int64 `protobuf:"varint,2,opt,name=time" json:"time,omitempty"` + // If uncertainty is omitted, it is interpreted as unknown. + // If the prediction is unknown or too uncertain, the delay (or time) field + // should be empty. In such case, the uncertainty field is ignored. + // To specify a completely certain prediction, set its uncertainty to 0. + Uncertainty *int32 `protobuf:"varint,3,opt,name=uncertainty" json:"uncertainty,omitempty"` +} + +func (x *TripUpdate_StopTimeEvent) Reset() { + *x = TripUpdate_StopTimeEvent{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TripUpdate_StopTimeEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TripUpdate_StopTimeEvent) ProtoMessage() {} + +func (x *TripUpdate_StopTimeEvent) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TripUpdate_StopTimeEvent.ProtoReflect.Descriptor instead. +func (*TripUpdate_StopTimeEvent) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{3, 0} +} + +func (x *TripUpdate_StopTimeEvent) GetDelay() int32 { + if x != nil && x.Delay != nil { + return *x.Delay + } + return 0 +} + +func (x *TripUpdate_StopTimeEvent) GetTime() int64 { + if x != nil && x.Time != nil { + return *x.Time + } + return 0 +} + +func (x *TripUpdate_StopTimeEvent) GetUncertainty() int32 { + if x != nil && x.Uncertainty != nil { + return *x.Uncertainty + } + return 0 +} + +// Realtime update for arrival and/or departure events for a given stop on a +// trip. Updates can be supplied for both past and future events. +// The producer is allowed, although not required, to drop past events. +type TripUpdate_StopTimeUpdate struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Must be the same as in stop_times.txt in the corresponding GTFS feed. + StopSequence *uint32 `protobuf:"varint,1,opt,name=stop_sequence,json=stopSequence" json:"stop_sequence,omitempty"` + // Must be the same as in stops.txt in the corresponding GTFS feed. + StopId *string `protobuf:"bytes,4,opt,name=stop_id,json=stopId" json:"stop_id,omitempty"` + Arrival *TripUpdate_StopTimeEvent `protobuf:"bytes,2,opt,name=arrival" json:"arrival,omitempty"` + Departure *TripUpdate_StopTimeEvent `protobuf:"bytes,3,opt,name=departure" json:"departure,omitempty"` + // Expected occupancy after departure from the given stop. + // Should be provided only for future stops. + // In order to provide departure_occupancy_status without either arrival or + // departure StopTimeEvents, ScheduleRelationship should be set to NO_DATA. + DepartureOccupancyStatus *VehiclePosition_OccupancyStatus `protobuf:"varint,7,opt,name=departure_occupancy_status,json=departureOccupancyStatus,enum=transit_realtime.VehiclePosition_OccupancyStatus" json:"departure_occupancy_status,omitempty"` + ScheduleRelationship *TripUpdate_StopTimeUpdate_ScheduleRelationship `protobuf:"varint,5,opt,name=schedule_relationship,json=scheduleRelationship,enum=transit_realtime.TripUpdate_StopTimeUpdate_ScheduleRelationship,def=0" json:"schedule_relationship,omitempty"` + // Realtime updates for certain properties defined within GTFS stop_times.txt + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + StopTimeProperties *TripUpdate_StopTimeUpdate_StopTimeProperties `protobuf:"bytes,6,opt,name=stop_time_properties,json=stopTimeProperties" json:"stop_time_properties,omitempty"` +} + +// Default values for TripUpdate_StopTimeUpdate fields. +const ( + Default_TripUpdate_StopTimeUpdate_ScheduleRelationship = TripUpdate_StopTimeUpdate_SCHEDULED +) + +func (x *TripUpdate_StopTimeUpdate) Reset() { + *x = TripUpdate_StopTimeUpdate{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TripUpdate_StopTimeUpdate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TripUpdate_StopTimeUpdate) ProtoMessage() {} + +func (x *TripUpdate_StopTimeUpdate) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TripUpdate_StopTimeUpdate.ProtoReflect.Descriptor instead. +func (*TripUpdate_StopTimeUpdate) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{3, 1} +} + +func (x *TripUpdate_StopTimeUpdate) GetStopSequence() uint32 { + if x != nil && x.StopSequence != nil { + return *x.StopSequence + } + return 0 +} + +func (x *TripUpdate_StopTimeUpdate) GetStopId() string { + if x != nil && x.StopId != nil { + return *x.StopId + } + return "" +} + +func (x *TripUpdate_StopTimeUpdate) GetArrival() *TripUpdate_StopTimeEvent { + if x != nil { + return x.Arrival + } + return nil +} + +func (x *TripUpdate_StopTimeUpdate) GetDeparture() *TripUpdate_StopTimeEvent { + if x != nil { + return x.Departure + } + return nil +} + +func (x *TripUpdate_StopTimeUpdate) GetDepartureOccupancyStatus() VehiclePosition_OccupancyStatus { + if x != nil && x.DepartureOccupancyStatus != nil { + return *x.DepartureOccupancyStatus + } + return VehiclePosition_EMPTY +} + +func (x *TripUpdate_StopTimeUpdate) GetScheduleRelationship() TripUpdate_StopTimeUpdate_ScheduleRelationship { + if x != nil && x.ScheduleRelationship != nil { + return *x.ScheduleRelationship + } + return Default_TripUpdate_StopTimeUpdate_ScheduleRelationship +} + +func (x *TripUpdate_StopTimeUpdate) GetStopTimeProperties() *TripUpdate_StopTimeUpdate_StopTimeProperties { + if x != nil { + return x.StopTimeProperties + } + return nil +} + +// Defines updated properties of the trip, such as a new shape_id when there is a detour. Or defines the +// trip_id, start_date, and start_time of a DUPLICATED trip. +// NOTE: This message is still experimental, and subject to change. It may be formally adopted in the future. +type TripUpdate_TripProperties struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Defines the identifier of a new trip that is a duplicate of an existing trip defined in (CSV) GTFS trips.txt + // but will start at a different service date and/or time (defined using the TripProperties.start_date and + // TripProperties.start_time fields). See definition of trips.trip_id in (CSV) GTFS. Its value must be different + // than the ones used in the (CSV) GTFS. Required if schedule_relationship=DUPLICATED, otherwise this field must not + // be populated and will be ignored by consumers. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + TripId *string `protobuf:"bytes,1,opt,name=trip_id,json=tripId" json:"trip_id,omitempty"` + // Service date on which the DUPLICATED trip will be run, in YYYYMMDD format. Required if + // schedule_relationship=DUPLICATED, otherwise this field must not be populated and will be ignored by consumers. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + StartDate *string `protobuf:"bytes,2,opt,name=start_date,json=startDate" json:"start_date,omitempty"` + // Defines the departure start time of the trip when it’s duplicated. See definition of stop_times.departure_time + // in (CSV) GTFS. Scheduled arrival and departure times for the duplicated trip are calculated based on the offset + // between the original trip departure_time and this field. For example, if a GTFS trip has stop A with a + // departure_time of 10:00:00 and stop B with departure_time of 10:01:00, and this field is populated with the value + // of 10:30:00, stop B on the duplicated trip will have a scheduled departure_time of 10:31:00. Real-time prediction + // delay values are applied to this calculated schedule time to determine the predicted time. For example, if a + // departure delay of 30 is provided for stop B, then the predicted departure time is 10:31:30. Real-time + // prediction time values do not have any offset applied to them and indicate the predicted time as provided. + // For example, if a departure time representing 10:31:30 is provided for stop B, then the predicted departure time + // is 10:31:30. This field is required if schedule_relationship is DUPLICATED, otherwise this field must not be + // populated and will be ignored by consumers. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + StartTime *string `protobuf:"bytes,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"` + // Specifies the shape of the vehicle travel path when the trip shape differs from the shape specified in + // (CSV) GTFS or to specify it in real-time when it's not provided by (CSV) GTFS, such as a vehicle that takes differing + // paths based on rider demand. See definition of trips.shape_id in (CSV) GTFS. If a shape is neither defined in (CSV) GTFS + // nor in real-time, the shape is considered unknown. This field can refer to a shape defined in the (CSV) GTFS in shapes.txt + // or a Shape in the (protobuf) real-time feed. The order of stops (stop sequences) for this trip must remain the same as + // (CSV) GTFS. Stops that are a part of the original trip but will no longer be made, such as when a detour occurs, should + // be marked as schedule_relationship=SKIPPED. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + ShapeId *string `protobuf:"bytes,4,opt,name=shape_id,json=shapeId" json:"shape_id,omitempty"` +} + +func (x *TripUpdate_TripProperties) Reset() { + *x = TripUpdate_TripProperties{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TripUpdate_TripProperties) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TripUpdate_TripProperties) ProtoMessage() {} + +func (x *TripUpdate_TripProperties) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TripUpdate_TripProperties.ProtoReflect.Descriptor instead. +func (*TripUpdate_TripProperties) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{3, 2} +} + +func (x *TripUpdate_TripProperties) GetTripId() string { + if x != nil && x.TripId != nil { + return *x.TripId + } + return "" +} + +func (x *TripUpdate_TripProperties) GetStartDate() string { + if x != nil && x.StartDate != nil { + return *x.StartDate + } + return "" +} + +func (x *TripUpdate_TripProperties) GetStartTime() string { + if x != nil && x.StartTime != nil { + return *x.StartTime + } + return "" +} + +func (x *TripUpdate_TripProperties) GetShapeId() string { + if x != nil && x.ShapeId != nil { + return *x.ShapeId + } + return "" +} + +// Provides the updated values for the stop time. +// NOTE: This message is still experimental, and subject to change. It may be formally adopted in the future. +type TripUpdate_StopTimeUpdate_StopTimeProperties struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Supports real-time stop assignments. Refers to a stop_id defined in the GTFS stops.txt. + // The new assigned_stop_id should not result in a significantly different trip experience for the end user than + // the stop_id defined in GTFS stop_times.txt. In other words, the end user should not view this new stop_id as an + // "unusual change" if the new stop was presented within an app without any additional context. + // For example, this field is intended to be used for platform assignments by using a stop_id that belongs to the + // same station as the stop originally defined in GTFS stop_times.txt. + // To assign a stop without providing any real-time arrival or departure predictions, populate this field and set + // StopTimeUpdate.schedule_relationship = NO_DATA. + // If this field is populated, it is preferred to omit `StopTimeUpdate.stop_id` and use only `StopTimeUpdate.stop_sequence`. If + // `StopTimeProperties.assigned_stop_id` and `StopTimeUpdate.stop_id` are populated, `StopTimeUpdate.stop_id` must match `assigned_stop_id`. + // Platform assignments should be reflected in other GTFS-realtime fields as well + // (e.g., `VehiclePosition.stop_id`). + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + AssignedStopId *string `protobuf:"bytes,1,opt,name=assigned_stop_id,json=assignedStopId" json:"assigned_stop_id,omitempty"` +} + +func (x *TripUpdate_StopTimeUpdate_StopTimeProperties) Reset() { + *x = TripUpdate_StopTimeUpdate_StopTimeProperties{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TripUpdate_StopTimeUpdate_StopTimeProperties) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TripUpdate_StopTimeUpdate_StopTimeProperties) ProtoMessage() {} + +func (x *TripUpdate_StopTimeUpdate_StopTimeProperties) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TripUpdate_StopTimeUpdate_StopTimeProperties.ProtoReflect.Descriptor instead. +func (*TripUpdate_StopTimeUpdate_StopTimeProperties) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{3, 1, 0} +} + +func (x *TripUpdate_StopTimeUpdate_StopTimeProperties) GetAssignedStopId() string { + if x != nil && x.AssignedStopId != nil { + return *x.AssignedStopId + } + return "" +} + +// Carriage specific details, used for vehicles composed of several carriages +// This message/field is still experimental, and subject to change. It may be formally adopted in the future. +type VehiclePosition_CarriageDetails struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // Identification of the carriage. Should be unique per vehicle. + Id *string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` + // User visible label that may be shown to the passenger to help identify + // the carriage. Example: "7712", "Car ABC-32", etc... + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + Label *string `protobuf:"bytes,2,opt,name=label" json:"label,omitempty"` + // Occupancy status for this given carriage, in this vehicle + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + OccupancyStatus *VehiclePosition_OccupancyStatus `protobuf:"varint,3,opt,name=occupancy_status,json=occupancyStatus,enum=transit_realtime.VehiclePosition_OccupancyStatus,def=7" json:"occupancy_status,omitempty"` + // Occupancy percentage for this given carriage, in this vehicle. + // Follows the same rules as "VehiclePosition.occupancy_percentage" + // -1 in case data is not available for this given carriage (as protobuf defaults to 0 otherwise) + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + OccupancyPercentage *int32 `protobuf:"varint,4,opt,name=occupancy_percentage,json=occupancyPercentage,def=-1" json:"occupancy_percentage,omitempty"` + // Identifies the order of this carriage with respect to the other + // carriages in the vehicle's list of CarriageDetails. + // The first carriage in the direction of travel must have a value of 1. + // The second value corresponds to the second carriage in the direction + // of travel and must have a value of 2, and so forth. + // For example, the first carriage in the direction of travel has a value of 1. + // If the second carriage in the direction of travel has a value of 3, + // consumers will discard data for all carriages (i.e., the multi_carriage_details field). + // Carriages without data must be represented with a valid carriage_sequence number and the fields + // without data should be omitted (alternately, those fields could also be included and set to the "no data" values). + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + CarriageSequence *uint32 `protobuf:"varint,5,opt,name=carriage_sequence,json=carriageSequence" json:"carriage_sequence,omitempty"` +} + +// Default values for VehiclePosition_CarriageDetails fields. +const ( + Default_VehiclePosition_CarriageDetails_OccupancyStatus = VehiclePosition_NO_DATA_AVAILABLE + Default_VehiclePosition_CarriageDetails_OccupancyPercentage = int32(-1) +) + +func (x *VehiclePosition_CarriageDetails) Reset() { + *x = VehiclePosition_CarriageDetails{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *VehiclePosition_CarriageDetails) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*VehiclePosition_CarriageDetails) ProtoMessage() {} + +func (x *VehiclePosition_CarriageDetails) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use VehiclePosition_CarriageDetails.ProtoReflect.Descriptor instead. +func (*VehiclePosition_CarriageDetails) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{4, 0} +} + +func (x *VehiclePosition_CarriageDetails) GetId() string { + if x != nil && x.Id != nil { + return *x.Id + } + return "" +} + +func (x *VehiclePosition_CarriageDetails) GetLabel() string { + if x != nil && x.Label != nil { + return *x.Label + } + return "" +} + +func (x *VehiclePosition_CarriageDetails) GetOccupancyStatus() VehiclePosition_OccupancyStatus { + if x != nil && x.OccupancyStatus != nil { + return *x.OccupancyStatus + } + return Default_VehiclePosition_CarriageDetails_OccupancyStatus +} + +func (x *VehiclePosition_CarriageDetails) GetOccupancyPercentage() int32 { + if x != nil && x.OccupancyPercentage != nil { + return *x.OccupancyPercentage + } + return Default_VehiclePosition_CarriageDetails_OccupancyPercentage +} + +func (x *VehiclePosition_CarriageDetails) GetCarriageSequence() uint32 { + if x != nil && x.CarriageSequence != nil { + return *x.CarriageSequence + } + return 0 +} + +type TranslatedString_Translation struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // A UTF-8 string containing the message. + Text *string `protobuf:"bytes,1,req,name=text" json:"text,omitempty"` + // BCP-47 language code. Can be omitted if the language is unknown or if + // no i18n is done at all for the feed. At most one translation is + // allowed to have an unspecified language tag. + Language *string `protobuf:"bytes,2,opt,name=language" json:"language,omitempty"` +} + +func (x *TranslatedString_Translation) Reset() { + *x = TranslatedString_Translation{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TranslatedString_Translation) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TranslatedString_Translation) ProtoMessage() {} + +func (x *TranslatedString_Translation) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TranslatedString_Translation.ProtoReflect.Descriptor instead. +func (*TranslatedString_Translation) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{11, 0} +} + +func (x *TranslatedString_Translation) GetText() string { + if x != nil && x.Text != nil { + return *x.Text + } + return "" +} + +func (x *TranslatedString_Translation) GetLanguage() string { + if x != nil && x.Language != nil { + return *x.Language + } + return "" +} + +type TranslatedImage_LocalizedImage struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + // String containing an URL linking to an image + // The image linked must be less than 2MB. + // If an image changes in a significant enough way that an update is required on the consumer side, the producer must update the URL to a new one. + // The URL should be a fully qualified URL that includes http:// or https://, and any special characters in the URL must be correctly escaped. See the following http://www.w3.org/Addressing/URL/4_URI_Recommentations.html for a description of how to create fully qualified URL values. + Url *string `protobuf:"bytes,1,req,name=url" json:"url,omitempty"` + // IANA media type as to specify the type of image to be displayed. + // The type must start with "image/" + MediaType *string `protobuf:"bytes,2,req,name=media_type,json=mediaType" json:"media_type,omitempty"` + // BCP-47 language code. Can be omitted if the language is unknown or if + // no i18n is done at all for the feed. At most one translation is + // allowed to have an unspecified language tag. + Language *string `protobuf:"bytes,3,opt,name=language" json:"language,omitempty"` +} + +func (x *TranslatedImage_LocalizedImage) Reset() { + *x = TranslatedImage_LocalizedImage{} + if protoimpl.UnsafeEnabled { + mi := &file_gtfs_realtime_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *TranslatedImage_LocalizedImage) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*TranslatedImage_LocalizedImage) ProtoMessage() {} + +func (x *TranslatedImage_LocalizedImage) ProtoReflect() protoreflect.Message { + mi := &file_gtfs_realtime_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use TranslatedImage_LocalizedImage.ProtoReflect.Descriptor instead. +func (*TranslatedImage_LocalizedImage) Descriptor() ([]byte, []int) { + return file_gtfs_realtime_proto_rawDescGZIP(), []int{12, 0} +} + +func (x *TranslatedImage_LocalizedImage) GetUrl() string { + if x != nil && x.Url != nil { + return *x.Url + } + return "" +} + +func (x *TranslatedImage_LocalizedImage) GetMediaType() string { + if x != nil && x.MediaType != nil { + return *x.MediaType + } + return "" +} + +func (x *TranslatedImage_LocalizedImage) GetLanguage() string { + if x != nil && x.Language != nil { + return *x.Language + } + return "" +} + +var File_gtfs_realtime_proto protoreflect.FileDescriptor + +var file_gtfs_realtime_proto_rawDesc = []byte{ + 0x0a, 0x13, 0x67, 0x74, 0x66, 0x73, 0x2d, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x10, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, + 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x22, 0x89, 0x01, 0x0a, 0x0b, 0x46, 0x65, 0x65, 0x64, + 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x34, 0x0a, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, + 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x46, 0x65, 0x65, 0x64, 0x48, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x52, 0x06, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x34, 0x0a, + 0x06, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x46, 0x65, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x52, 0x06, 0x65, 0x6e, 0x74, + 0x69, 0x74, 0x79, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, + 0x10, 0x90, 0x4e, 0x22, 0x87, 0x02, 0x0a, 0x0a, 0x46, 0x65, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x12, 0x32, 0x0a, 0x15, 0x67, 0x74, 0x66, 0x73, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, + 0x69, 0x6d, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x02, 0x28, + 0x09, 0x52, 0x13, 0x67, 0x74, 0x66, 0x73, 0x52, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x61, 0x0a, 0x0e, 0x69, 0x6e, 0x63, 0x72, 0x65, 0x6d, + 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2b, + 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x46, 0x65, 0x65, 0x64, 0x48, 0x65, 0x61, 0x64, 0x65, 0x72, 0x2e, 0x49, 0x6e, 0x63, + 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x3a, 0x0c, 0x46, 0x55, 0x4c, + 0x4c, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x53, 0x45, 0x54, 0x52, 0x0e, 0x69, 0x6e, 0x63, 0x72, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, + 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0x34, 0x0a, 0x0e, 0x49, 0x6e, 0x63, 0x72, 0x65, + 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x12, 0x10, 0x0a, 0x0c, 0x46, 0x55, 0x4c, + 0x4c, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x53, 0x45, 0x54, 0x10, 0x00, 0x12, 0x10, 0x0a, 0x0c, 0x44, + 0x49, 0x46, 0x46, 0x45, 0x52, 0x45, 0x4e, 0x54, 0x49, 0x41, 0x4c, 0x10, 0x01, 0x2a, 0x06, 0x08, + 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xac, 0x02, + 0x0a, 0x0a, 0x46, 0x65, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x0e, 0x0a, 0x02, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x24, 0x0a, 0x0a, + 0x69, 0x73, 0x5f, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, + 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x52, 0x09, 0x69, 0x73, 0x44, 0x65, 0x6c, 0x65, 0x74, + 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x0b, 0x74, 0x72, 0x69, 0x70, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, + 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x55, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0a, 0x74, 0x72, 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x12, 0x3b, 0x0a, 0x07, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, + 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x12, 0x2d, + 0x0a, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x52, 0x05, 0x61, 0x6c, 0x65, 0x72, 0x74, 0x12, 0x2d, 0x0a, + 0x05, 0x73, 0x68, 0x61, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, + 0x53, 0x68, 0x61, 0x70, 0x65, 0x52, 0x05, 0x73, 0x68, 0x61, 0x70, 0x65, 0x2a, 0x06, 0x08, 0xe8, + 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xed, 0x0a, 0x0a, + 0x0a, 0x54, 0x72, 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x34, 0x0a, 0x04, 0x74, + 0x72, 0x69, 0x70, 0x18, 0x01, 0x20, 0x02, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, + 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x04, 0x74, 0x72, 0x69, + 0x70, 0x12, 0x3d, 0x0a, 0x07, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, + 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x44, 0x65, 0x73, + 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, + 0x12, 0x55, 0x0a, 0x10, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x5f, 0x75, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x74, 0x72, 0x61, + 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, + 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, + 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x0e, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, + 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, + 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, + 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x54, 0x0a, 0x0f, 0x74, + 0x72, 0x69, 0x70, 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2b, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, + 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, + 0x74, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, + 0x73, 0x52, 0x0e, 0x74, 0x72, 0x69, 0x70, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, + 0x73, 0x1a, 0x6b, 0x0a, 0x0d, 0x53, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x05, 0x64, 0x65, 0x6c, 0x61, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x74, 0x69, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, + 0x75, 0x6e, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x74, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0b, 0x75, 0x6e, 0x63, 0x65, 0x72, 0x74, 0x61, 0x69, 0x6e, 0x74, 0x79, 0x2a, 0x06, + 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x1a, 0xf6, + 0x05, 0x0a, 0x0e, 0x53, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, + 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0c, 0x73, 0x74, 0x6f, 0x70, 0x53, 0x65, + 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x69, + 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x6f, 0x70, 0x49, 0x64, 0x12, + 0x44, 0x0a, 0x07, 0x61, 0x72, 0x72, 0x69, 0x76, 0x61, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2a, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, + 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, + 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x07, 0x61, 0x72, + 0x72, 0x69, 0x76, 0x61, 0x6c, 0x12, 0x48, 0x0a, 0x09, 0x64, 0x65, 0x70, 0x61, 0x72, 0x74, 0x75, + 0x72, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2a, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, + 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x45, + 0x76, 0x65, 0x6e, 0x74, 0x52, 0x09, 0x64, 0x65, 0x70, 0x61, 0x72, 0x74, 0x75, 0x72, 0x65, 0x12, + 0x6f, 0x0a, 0x1a, 0x64, 0x65, 0x70, 0x61, 0x72, 0x74, 0x75, 0x72, 0x65, 0x5f, 0x6f, 0x63, 0x63, + 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, + 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, + 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x18, 0x64, 0x65, 0x70, 0x61, 0x72, 0x74, 0x75, 0x72, + 0x65, 0x4f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x12, 0x80, 0x01, 0x0a, 0x15, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x5f, 0x72, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x40, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, + 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, + 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, 0x63, + 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, + 0x69, 0x70, 0x3a, 0x09, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, 0x4c, 0x45, 0x44, 0x52, 0x14, 0x73, + 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x68, 0x69, 0x70, 0x12, 0x70, 0x0a, 0x14, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x5f, 0x70, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x3e, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, + 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, + 0x53, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x2e, 0x53, + 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, + 0x73, 0x52, 0x12, 0x73, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, + 0x72, 0x74, 0x69, 0x65, 0x73, 0x1a, 0x4e, 0x0a, 0x12, 0x53, 0x74, 0x6f, 0x70, 0x54, 0x69, 0x6d, + 0x65, 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x10, 0x61, + 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x5f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0e, 0x61, 0x73, 0x73, 0x69, 0x67, 0x6e, 0x65, 0x64, 0x53, + 0x74, 0x6f, 0x70, 0x49, 0x64, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, + 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0x50, 0x0a, 0x14, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, + 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x12, 0x0d, 0x0a, + 0x09, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, + 0x53, 0x4b, 0x49, 0x50, 0x50, 0x45, 0x44, 0x10, 0x01, 0x12, 0x0b, 0x0a, 0x07, 0x4e, 0x4f, 0x5f, + 0x44, 0x41, 0x54, 0x41, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e, 0x53, 0x43, 0x48, 0x45, + 0x44, 0x55, 0x4c, 0x45, 0x44, 0x10, 0x03, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, + 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x1a, 0x92, 0x01, 0x0a, 0x0e, 0x54, 0x72, 0x69, 0x70, + 0x50, 0x72, 0x6f, 0x70, 0x65, 0x72, 0x74, 0x69, 0x65, 0x73, 0x12, 0x17, 0x0a, 0x07, 0x74, 0x72, + 0x69, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x74, 0x72, 0x69, + 0x70, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x64, 0x61, 0x74, + 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x44, 0x61, + 0x74, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, 0x74, 0x54, 0x69, 0x6d, + 0x65, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x68, 0x61, 0x70, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x68, 0x61, 0x70, 0x65, 0x49, 0x64, 0x2a, 0x06, 0x08, 0xe8, + 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x2a, 0x06, 0x08, 0xe8, + 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xbf, 0x0b, 0x0a, + 0x0f, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x12, 0x34, 0x0a, 0x04, 0x74, 0x72, 0x69, 0x70, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, + 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, + 0x52, 0x04, 0x74, 0x72, 0x69, 0x70, 0x12, 0x3d, 0x0a, 0x07, 0x76, 0x65, 0x68, 0x69, 0x63, 0x6c, + 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, + 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, + 0x6c, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x52, 0x07, 0x76, 0x65, + 0x68, 0x69, 0x63, 0x6c, 0x65, 0x12, 0x36, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, + 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, + 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x73, 0x65, + 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x6f, 0x70, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, + 0x65, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x74, 0x6f, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x6f, 0x70, 0x49, 0x64, 0x12, 0x69, 0x0a, 0x0e, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x33, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, + 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x53, 0x74, 0x6f, + 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x3a, 0x0d, 0x49, 0x4e, 0x5f, 0x54, 0x52, 0x41, 0x4e, + 0x53, 0x49, 0x54, 0x5f, 0x54, 0x4f, 0x52, 0x0d, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, + 0x61, 0x6d, 0x70, 0x12, 0x5c, 0x0a, 0x10, 0x63, 0x6f, 0x6e, 0x67, 0x65, 0x73, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, + 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x2e, 0x43, 0x6f, 0x6e, 0x67, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, + 0x52, 0x0f, 0x63, 0x6f, 0x6e, 0x67, 0x65, 0x73, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x65, 0x76, 0x65, + 0x6c, 0x12, 0x5c, 0x0a, 0x10, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x5f, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x31, 0x2e, 0x74, 0x72, + 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, + 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x4f, + 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x0f, + 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x31, 0x0a, 0x14, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x5f, 0x70, 0x65, 0x72, + 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x13, 0x6f, + 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, + 0x67, 0x65, 0x12, 0x67, 0x0a, 0x16, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x5f, 0x63, 0x61, 0x72, 0x72, + 0x69, 0x61, 0x67, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x18, 0x0b, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, + 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x43, 0x61, 0x72, 0x72, 0x69, 0x61, 0x67, 0x65, 0x44, 0x65, + 0x74, 0x61, 0x69, 0x6c, 0x73, 0x52, 0x14, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x43, 0x61, 0x72, 0x72, + 0x69, 0x61, 0x67, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x1a, 0x9c, 0x02, 0x0a, 0x0f, + 0x43, 0x61, 0x72, 0x72, 0x69, 0x61, 0x67, 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x73, 0x12, + 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x14, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, + 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x6f, 0x0a, 0x10, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, + 0x63, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x31, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, + 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x2e, 0x4f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x3a, 0x11, 0x4e, 0x4f, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x41, 0x56, 0x41, 0x49, + 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x52, 0x0f, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x35, 0x0a, 0x14, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, + 0x6e, 0x63, 0x79, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x05, 0x3a, 0x02, 0x2d, 0x31, 0x52, 0x13, 0x6f, 0x63, 0x63, 0x75, 0x70, 0x61, + 0x6e, 0x63, 0x79, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x2b, 0x0a, + 0x11, 0x63, 0x61, 0x72, 0x72, 0x69, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x71, 0x75, 0x65, 0x6e, + 0x63, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x10, 0x63, 0x61, 0x72, 0x72, 0x69, 0x61, + 0x67, 0x65, 0x53, 0x65, 0x71, 0x75, 0x65, 0x6e, 0x63, 0x65, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, + 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0x47, 0x0a, 0x11, 0x56, 0x65, + 0x68, 0x69, 0x63, 0x6c, 0x65, 0x53, 0x74, 0x6f, 0x70, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, + 0x0f, 0x0a, 0x0b, 0x49, 0x4e, 0x43, 0x4f, 0x4d, 0x49, 0x4e, 0x47, 0x5f, 0x41, 0x54, 0x10, 0x00, + 0x12, 0x0e, 0x0a, 0x0a, 0x53, 0x54, 0x4f, 0x50, 0x50, 0x45, 0x44, 0x5f, 0x41, 0x54, 0x10, 0x01, + 0x12, 0x11, 0x0a, 0x0d, 0x49, 0x4e, 0x5f, 0x54, 0x52, 0x41, 0x4e, 0x53, 0x49, 0x54, 0x5f, 0x54, + 0x4f, 0x10, 0x02, 0x22, 0x7d, 0x0a, 0x0f, 0x43, 0x6f, 0x6e, 0x67, 0x65, 0x73, 0x74, 0x69, 0x6f, + 0x6e, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1c, 0x0a, 0x18, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, + 0x4e, 0x5f, 0x43, 0x4f, 0x4e, 0x47, 0x45, 0x53, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4c, 0x45, 0x56, + 0x45, 0x4c, 0x10, 0x00, 0x12, 0x14, 0x0a, 0x10, 0x52, 0x55, 0x4e, 0x4e, 0x49, 0x4e, 0x47, 0x5f, + 0x53, 0x4d, 0x4f, 0x4f, 0x54, 0x48, 0x4c, 0x59, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x53, 0x54, + 0x4f, 0x50, 0x5f, 0x41, 0x4e, 0x44, 0x5f, 0x47, 0x4f, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x43, + 0x4f, 0x4e, 0x47, 0x45, 0x53, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x03, 0x12, 0x15, 0x0a, 0x11, 0x53, + 0x45, 0x56, 0x45, 0x52, 0x45, 0x5f, 0x43, 0x4f, 0x4e, 0x47, 0x45, 0x53, 0x54, 0x49, 0x4f, 0x4e, + 0x10, 0x04, 0x22, 0xd9, 0x01, 0x0a, 0x0f, 0x4f, 0x63, 0x63, 0x75, 0x70, 0x61, 0x6e, 0x63, 0x79, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x4d, 0x50, 0x54, 0x59, 0x10, + 0x00, 0x12, 0x18, 0x0a, 0x14, 0x4d, 0x41, 0x4e, 0x59, 0x5f, 0x53, 0x45, 0x41, 0x54, 0x53, 0x5f, + 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x12, 0x17, 0x0a, 0x13, 0x46, + 0x45, 0x57, 0x5f, 0x53, 0x45, 0x41, 0x54, 0x53, 0x5f, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, + 0x4c, 0x45, 0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x49, 0x4e, 0x47, + 0x5f, 0x52, 0x4f, 0x4f, 0x4d, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x03, 0x12, 0x1e, 0x0a, 0x1a, + 0x43, 0x52, 0x55, 0x53, 0x48, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x4e, 0x44, 0x49, 0x4e, 0x47, + 0x5f, 0x52, 0x4f, 0x4f, 0x4d, 0x5f, 0x4f, 0x4e, 0x4c, 0x59, 0x10, 0x04, 0x12, 0x08, 0x0a, 0x04, + 0x46, 0x55, 0x4c, 0x4c, 0x10, 0x05, 0x12, 0x1c, 0x0a, 0x18, 0x4e, 0x4f, 0x54, 0x5f, 0x41, 0x43, + 0x43, 0x45, 0x50, 0x54, 0x49, 0x4e, 0x47, 0x5f, 0x50, 0x41, 0x53, 0x53, 0x45, 0x4e, 0x47, 0x45, + 0x52, 0x53, 0x10, 0x06, 0x12, 0x15, 0x0a, 0x11, 0x4e, 0x4f, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, + 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x07, 0x12, 0x11, 0x0a, 0x0d, 0x4e, + 0x4f, 0x54, 0x5f, 0x42, 0x4f, 0x41, 0x52, 0x44, 0x41, 0x42, 0x4c, 0x45, 0x10, 0x08, 0x2a, 0x06, + 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xa4, + 0x0c, 0x0a, 0x05, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x12, 0x40, 0x0a, 0x0d, 0x61, 0x63, 0x74, 0x69, + 0x76, 0x65, 0x5f, 0x70, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, + 0x6d, 0x65, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x0c, 0x61, 0x63, + 0x74, 0x69, 0x76, 0x65, 0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x12, 0x49, 0x0a, 0x0f, 0x69, 0x6e, + 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x18, 0x05, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, + 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x45, 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x65, 0x6c, + 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x0e, 0x69, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x65, 0x64, 0x45, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x12, 0x42, 0x0a, 0x05, 0x63, 0x61, 0x75, 0x73, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, + 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x2e, 0x43, 0x61, + 0x75, 0x73, 0x65, 0x3a, 0x0d, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x43, 0x41, 0x55, + 0x53, 0x45, 0x52, 0x05, 0x63, 0x61, 0x75, 0x73, 0x65, 0x12, 0x46, 0x0a, 0x06, 0x65, 0x66, 0x66, + 0x65, 0x63, 0x74, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x41, 0x6c, 0x65, + 0x72, 0x74, 0x2e, 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x3a, 0x0e, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, + 0x57, 0x4e, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, 0x54, 0x52, 0x06, 0x65, 0x66, 0x66, 0x65, 0x63, + 0x74, 0x12, 0x34, 0x0a, 0x03, 0x75, 0x72, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, 0x43, 0x0a, 0x0b, 0x68, 0x65, 0x61, 0x64, 0x65, + 0x72, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x52, 0x0a, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x54, 0x65, 0x78, 0x74, 0x12, 0x4d, 0x0a, 0x10, + 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x65, 0x78, 0x74, + 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, + 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0f, 0x64, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x65, 0x78, 0x74, 0x12, 0x4a, 0x0a, 0x0f, 0x74, + 0x74, 0x73, 0x5f, 0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x18, 0x0c, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, + 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, + 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0d, 0x74, 0x74, 0x73, 0x48, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x54, 0x65, 0x78, 0x74, 0x12, 0x54, 0x0a, 0x14, 0x74, 0x74, 0x73, 0x5f, 0x64, + 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, 0x65, 0x78, 0x74, 0x18, + 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, + 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, + 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x12, 0x74, 0x74, 0x73, 0x44, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x65, 0x78, 0x74, 0x12, 0x5e, 0x0a, + 0x0e, 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, + 0x0e, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x25, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, + 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x41, 0x6c, 0x65, 0x72, 0x74, 0x2e, 0x53, + 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x3a, 0x10, 0x55, 0x4e, + 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x53, 0x45, 0x56, 0x45, 0x52, 0x49, 0x54, 0x59, 0x52, 0x0d, + 0x73, 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x37, 0x0a, + 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, + 0x05, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x58, 0x0a, 0x16, 0x69, 0x6d, 0x61, 0x67, 0x65, 0x5f, + 0x61, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x5f, 0x74, 0x65, 0x78, 0x74, + 0x18, 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, + 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x14, 0x69, 0x6d, 0x61, 0x67, + 0x65, 0x41, 0x6c, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x74, 0x69, 0x76, 0x65, 0x54, 0x65, 0x78, 0x74, + 0x12, 0x45, 0x0a, 0x0c, 0x63, 0x61, 0x75, 0x73, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, + 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, + 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x0b, 0x63, 0x61, 0x75, 0x73, + 0x65, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x47, 0x0a, 0x0d, 0x65, 0x66, 0x66, 0x65, 0x63, + 0x74, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, + 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x52, 0x0c, 0x65, 0x66, 0x66, 0x65, 0x63, 0x74, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, + 0x22, 0xd8, 0x01, 0x0a, 0x05, 0x43, 0x61, 0x75, 0x73, 0x65, 0x12, 0x11, 0x0a, 0x0d, 0x55, 0x4e, + 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x43, 0x41, 0x55, 0x53, 0x45, 0x10, 0x01, 0x12, 0x0f, 0x0a, + 0x0b, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x5f, 0x43, 0x41, 0x55, 0x53, 0x45, 0x10, 0x02, 0x12, 0x15, + 0x0a, 0x11, 0x54, 0x45, 0x43, 0x48, 0x4e, 0x49, 0x43, 0x41, 0x4c, 0x5f, 0x50, 0x52, 0x4f, 0x42, + 0x4c, 0x45, 0x4d, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x54, 0x52, 0x49, 0x4b, 0x45, 0x10, + 0x04, 0x12, 0x11, 0x0a, 0x0d, 0x44, 0x45, 0x4d, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x41, 0x54, 0x49, + 0x4f, 0x4e, 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, 0x41, 0x43, 0x43, 0x49, 0x44, 0x45, 0x4e, 0x54, + 0x10, 0x06, 0x12, 0x0b, 0x0a, 0x07, 0x48, 0x4f, 0x4c, 0x49, 0x44, 0x41, 0x59, 0x10, 0x07, 0x12, + 0x0b, 0x0a, 0x07, 0x57, 0x45, 0x41, 0x54, 0x48, 0x45, 0x52, 0x10, 0x08, 0x12, 0x0f, 0x0a, 0x0b, + 0x4d, 0x41, 0x49, 0x4e, 0x54, 0x45, 0x4e, 0x41, 0x4e, 0x43, 0x45, 0x10, 0x09, 0x12, 0x10, 0x0a, + 0x0c, 0x43, 0x4f, 0x4e, 0x53, 0x54, 0x52, 0x55, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x0a, 0x12, + 0x13, 0x0a, 0x0f, 0x50, 0x4f, 0x4c, 0x49, 0x43, 0x45, 0x5f, 0x41, 0x43, 0x54, 0x49, 0x56, 0x49, + 0x54, 0x59, 0x10, 0x0b, 0x12, 0x15, 0x0a, 0x11, 0x4d, 0x45, 0x44, 0x49, 0x43, 0x41, 0x4c, 0x5f, + 0x45, 0x4d, 0x45, 0x52, 0x47, 0x45, 0x4e, 0x43, 0x59, 0x10, 0x0c, 0x22, 0xdd, 0x01, 0x0a, 0x06, + 0x45, 0x66, 0x66, 0x65, 0x63, 0x74, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x4f, 0x5f, 0x53, 0x45, 0x52, + 0x56, 0x49, 0x43, 0x45, 0x10, 0x01, 0x12, 0x13, 0x0a, 0x0f, 0x52, 0x45, 0x44, 0x55, 0x43, 0x45, + 0x44, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x02, 0x12, 0x16, 0x0a, 0x12, 0x53, + 0x49, 0x47, 0x4e, 0x49, 0x46, 0x49, 0x43, 0x41, 0x4e, 0x54, 0x5f, 0x44, 0x45, 0x4c, 0x41, 0x59, + 0x53, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x44, 0x45, 0x54, 0x4f, 0x55, 0x52, 0x10, 0x04, 0x12, + 0x16, 0x0a, 0x12, 0x41, 0x44, 0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x5f, 0x53, 0x45, + 0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x05, 0x12, 0x14, 0x0a, 0x10, 0x4d, 0x4f, 0x44, 0x49, 0x46, + 0x49, 0x45, 0x44, 0x5f, 0x53, 0x45, 0x52, 0x56, 0x49, 0x43, 0x45, 0x10, 0x06, 0x12, 0x10, 0x0a, + 0x0c, 0x4f, 0x54, 0x48, 0x45, 0x52, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, 0x54, 0x10, 0x07, 0x12, + 0x12, 0x0a, 0x0e, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, + 0x54, 0x10, 0x08, 0x12, 0x0e, 0x0a, 0x0a, 0x53, 0x54, 0x4f, 0x50, 0x5f, 0x4d, 0x4f, 0x56, 0x45, + 0x44, 0x10, 0x09, 0x12, 0x0d, 0x0a, 0x09, 0x4e, 0x4f, 0x5f, 0x45, 0x46, 0x46, 0x45, 0x43, 0x54, + 0x10, 0x0a, 0x12, 0x17, 0x0a, 0x13, 0x41, 0x43, 0x43, 0x45, 0x53, 0x53, 0x49, 0x42, 0x49, 0x4c, + 0x49, 0x54, 0x59, 0x5f, 0x49, 0x53, 0x53, 0x55, 0x45, 0x10, 0x0b, 0x22, 0x48, 0x0a, 0x0d, 0x53, + 0x65, 0x76, 0x65, 0x72, 0x69, 0x74, 0x79, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x14, 0x0a, 0x10, + 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x53, 0x45, 0x56, 0x45, 0x52, 0x49, 0x54, 0x59, + 0x10, 0x01, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x4e, 0x46, 0x4f, 0x10, 0x02, 0x12, 0x0b, 0x0a, 0x07, + 0x57, 0x41, 0x52, 0x4e, 0x49, 0x4e, 0x47, 0x10, 0x03, 0x12, 0x0a, 0x0a, 0x06, 0x53, 0x45, 0x56, + 0x45, 0x52, 0x45, 0x10, 0x04, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, + 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0x43, 0x0a, 0x09, 0x54, 0x69, 0x6d, 0x65, 0x52, 0x61, 0x6e, + 0x67, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x65, 0x6e, 0x64, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x65, 0x6e, 0x64, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, + 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xa0, 0x01, 0x0a, 0x08, 0x50, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x61, 0x74, 0x69, 0x74, + 0x75, 0x64, 0x65, 0x18, 0x01, 0x20, 0x02, 0x28, 0x02, 0x52, 0x08, 0x6c, 0x61, 0x74, 0x69, 0x74, + 0x75, 0x64, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x6c, 0x6f, 0x6e, 0x67, 0x69, 0x74, 0x75, 0x64, 0x65, + 0x18, 0x02, 0x20, 0x02, 0x28, 0x02, 0x52, 0x09, 0x6c, 0x6f, 0x6e, 0x67, 0x69, 0x74, 0x75, 0x64, + 0x65, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x02, 0x52, 0x07, 0x62, 0x65, 0x61, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1a, 0x0a, 0x08, 0x6f, + 0x64, 0x6f, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x6f, + 0x64, 0x6f, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x70, 0x65, 0x65, 0x64, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x02, 0x52, 0x05, 0x73, 0x70, 0x65, 0x65, 0x64, 0x2a, 0x06, 0x08, + 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xa5, 0x03, + 0x0a, 0x0e, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, + 0x12, 0x17, 0x0a, 0x07, 0x74, 0x72, 0x69, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x06, 0x74, 0x72, 0x69, 0x70, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x6f, 0x75, + 0x74, 0x65, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x64, 0x69, 0x72, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, + 0x64, 0x61, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x73, 0x74, 0x61, 0x72, + 0x74, 0x44, 0x61, 0x74, 0x65, 0x12, 0x6a, 0x0a, 0x15, 0x73, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, + 0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x35, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, + 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, + 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52, + 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x52, 0x14, 0x73, 0x63, 0x68, + 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x65, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, + 0x70, 0x22, 0x81, 0x01, 0x0a, 0x14, 0x53, 0x63, 0x68, 0x65, 0x64, 0x75, 0x6c, 0x65, 0x52, 0x65, + 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x68, 0x69, 0x70, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x43, + 0x48, 0x45, 0x44, 0x55, 0x4c, 0x45, 0x44, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x44, 0x44, + 0x45, 0x44, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x4e, 0x53, 0x43, 0x48, 0x45, 0x44, 0x55, + 0x4c, 0x45, 0x44, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c, 0x45, + 0x44, 0x10, 0x03, 0x12, 0x13, 0x0a, 0x0b, 0x52, 0x45, 0x50, 0x4c, 0x41, 0x43, 0x45, 0x4d, 0x45, + 0x4e, 0x54, 0x10, 0x05, 0x1a, 0x02, 0x08, 0x01, 0x12, 0x0e, 0x0a, 0x0a, 0x44, 0x55, 0x50, 0x4c, + 0x49, 0x43, 0x41, 0x54, 0x45, 0x44, 0x10, 0x06, 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x45, 0x4c, 0x45, + 0x54, 0x45, 0x44, 0x10, 0x07, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, + 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xd2, 0x02, 0x0a, 0x11, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, + 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x12, 0x0e, 0x0a, 0x02, 0x69, + 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x6c, + 0x61, 0x62, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x6c, 0x61, 0x62, 0x65, + 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, 0x65, 0x5f, 0x70, 0x6c, 0x61, + 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6c, 0x69, 0x63, 0x65, 0x6e, 0x73, + 0x65, 0x50, 0x6c, 0x61, 0x74, 0x65, 0x12, 0x77, 0x0a, 0x15, 0x77, 0x68, 0x65, 0x65, 0x6c, 0x63, + 0x68, 0x61, 0x69, 0x72, 0x5f, 0x61, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x38, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, + 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x56, 0x65, 0x68, 0x69, 0x63, 0x6c, 0x65, + 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x57, 0x68, 0x65, 0x65, 0x6c, + 0x63, 0x68, 0x61, 0x69, 0x72, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x3a, + 0x08, 0x4e, 0x4f, 0x5f, 0x56, 0x41, 0x4c, 0x55, 0x45, 0x52, 0x14, 0x77, 0x68, 0x65, 0x65, 0x6c, + 0x63, 0x68, 0x61, 0x69, 0x72, 0x41, 0x63, 0x63, 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x22, + 0x69, 0x0a, 0x14, 0x57, 0x68, 0x65, 0x65, 0x6c, 0x63, 0x68, 0x61, 0x69, 0x72, 0x41, 0x63, 0x63, + 0x65, 0x73, 0x73, 0x69, 0x62, 0x6c, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x4f, 0x5f, 0x56, 0x41, + 0x4c, 0x55, 0x45, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, + 0x10, 0x01, 0x12, 0x19, 0x0a, 0x15, 0x57, 0x48, 0x45, 0x45, 0x4c, 0x43, 0x48, 0x41, 0x49, 0x52, + 0x5f, 0x41, 0x43, 0x43, 0x45, 0x53, 0x53, 0x49, 0x42, 0x4c, 0x45, 0x10, 0x02, 0x12, 0x1b, 0x0a, + 0x17, 0x57, 0x48, 0x45, 0x45, 0x4c, 0x43, 0x48, 0x41, 0x49, 0x52, 0x5f, 0x49, 0x4e, 0x41, 0x43, + 0x43, 0x45, 0x53, 0x53, 0x49, 0x42, 0x4c, 0x45, 0x10, 0x03, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, + 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xe9, 0x01, 0x0a, 0x0e, 0x45, + 0x6e, 0x74, 0x69, 0x74, 0x79, 0x53, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x12, 0x1b, 0x0a, + 0x09, 0x61, 0x67, 0x65, 0x6e, 0x63, 0x79, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x61, 0x67, 0x65, 0x6e, 0x63, 0x79, 0x49, 0x64, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x72, 0x6f, + 0x75, 0x74, 0x65, 0x49, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x6f, 0x75, 0x74, 0x65, 0x5f, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x72, 0x6f, 0x75, 0x74, 0x65, + 0x54, 0x79, 0x70, 0x65, 0x12, 0x34, 0x0a, 0x04, 0x74, 0x72, 0x69, 0x70, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, + 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x69, 0x70, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, + 0x70, 0x74, 0x6f, 0x72, 0x52, 0x04, 0x74, 0x72, 0x69, 0x70, 0x12, 0x17, 0x0a, 0x07, 0x73, 0x74, + 0x6f, 0x70, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x74, 0x6f, + 0x70, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x5f, 0x69, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x0b, 0x64, 0x69, 0x72, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, + 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xc3, 0x01, 0x0a, 0x10, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x6c, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x50, 0x0a, 0x0b, 0x74, + 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x2e, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, + 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x1a, 0x4d, 0x0a, + 0x0b, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x12, 0x0a, 0x04, + 0x74, 0x65, 0x78, 0x74, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x04, 0x74, 0x65, 0x78, 0x74, + 0x12, 0x1a, 0x0a, 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x2a, 0x06, 0x08, 0xe8, + 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x2a, 0x06, 0x08, 0xe8, + 0x07, 0x10, 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0xeb, 0x01, 0x0a, + 0x0f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6d, 0x61, 0x67, 0x65, + 0x12, 0x59, 0x0a, 0x0f, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x69, 0x6d, + 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x30, 0x2e, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x69, 0x74, 0x5f, 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x54, 0x72, 0x61, + 0x6e, 0x73, 0x6c, 0x61, 0x74, 0x65, 0x64, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x2e, 0x4c, 0x6f, 0x63, + 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x52, 0x0e, 0x6c, 0x6f, 0x63, + 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x1a, 0x6d, 0x0a, 0x0e, 0x4c, + 0x6f, 0x63, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x49, 0x6d, 0x61, 0x67, 0x65, 0x12, 0x10, 0x0a, + 0x03, 0x75, 0x72, 0x6c, 0x18, 0x01, 0x20, 0x02, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x6c, 0x12, + 0x1d, 0x0a, 0x0a, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, + 0x02, 0x28, 0x09, 0x52, 0x09, 0x6d, 0x65, 0x64, 0x69, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1a, + 0x0a, 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x08, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, + 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, + 0xd0, 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x22, 0x5d, 0x0a, 0x05, 0x53, 0x68, + 0x61, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x73, 0x68, 0x61, 0x70, 0x65, 0x5f, 0x69, 0x64, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x73, 0x68, 0x61, 0x70, 0x65, 0x49, 0x64, 0x12, 0x29, + 0x0a, 0x10, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x6f, 0x6c, 0x79, 0x6c, 0x69, + 0x6e, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0f, 0x65, 0x6e, 0x63, 0x6f, 0x64, 0x65, + 0x64, 0x50, 0x6f, 0x6c, 0x79, 0x6c, 0x69, 0x6e, 0x65, 0x2a, 0x06, 0x08, 0xe8, 0x07, 0x10, 0xd0, + 0x0f, 0x2a, 0x06, 0x08, 0xa8, 0x46, 0x10, 0x90, 0x4e, 0x42, 0x1d, 0x0a, 0x1b, 0x63, 0x6f, 0x6d, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x69, 0x74, 0x2e, + 0x72, 0x65, 0x61, 0x6c, 0x74, 0x69, 0x6d, 0x65, +} + +var ( + file_gtfs_realtime_proto_rawDescOnce sync.Once + file_gtfs_realtime_proto_rawDescData = file_gtfs_realtime_proto_rawDesc +) + +func file_gtfs_realtime_proto_rawDescGZIP() []byte { + file_gtfs_realtime_proto_rawDescOnce.Do(func() { + file_gtfs_realtime_proto_rawDescData = protoimpl.X.CompressGZIP(file_gtfs_realtime_proto_rawDescData) + }) + return file_gtfs_realtime_proto_rawDescData +} + +var file_gtfs_realtime_proto_enumTypes = make([]protoimpl.EnumInfo, 10) +var file_gtfs_realtime_proto_msgTypes = make([]protoimpl.MessageInfo, 21) +var file_gtfs_realtime_proto_goTypes = []interface{}{ + (FeedHeader_Incrementality)(0), // 0: transit_realtime.FeedHeader.Incrementality + (TripUpdate_StopTimeUpdate_ScheduleRelationship)(0), // 1: transit_realtime.TripUpdate.StopTimeUpdate.ScheduleRelationship + (VehiclePosition_VehicleStopStatus)(0), // 2: transit_realtime.VehiclePosition.VehicleStopStatus + (VehiclePosition_CongestionLevel)(0), // 3: transit_realtime.VehiclePosition.CongestionLevel + (VehiclePosition_OccupancyStatus)(0), // 4: transit_realtime.VehiclePosition.OccupancyStatus + (Alert_Cause)(0), // 5: transit_realtime.Alert.Cause + (Alert_Effect)(0), // 6: transit_realtime.Alert.Effect + (Alert_SeverityLevel)(0), // 7: transit_realtime.Alert.SeverityLevel + (TripDescriptor_ScheduleRelationship)(0), // 8: transit_realtime.TripDescriptor.ScheduleRelationship + (VehicleDescriptor_WheelchairAccessible)(0), // 9: transit_realtime.VehicleDescriptor.WheelchairAccessible + (*FeedMessage)(nil), // 10: transit_realtime.FeedMessage + (*FeedHeader)(nil), // 11: transit_realtime.FeedHeader + (*FeedEntity)(nil), // 12: transit_realtime.FeedEntity + (*TripUpdate)(nil), // 13: transit_realtime.TripUpdate + (*VehiclePosition)(nil), // 14: transit_realtime.VehiclePosition + (*Alert)(nil), // 15: transit_realtime.Alert + (*TimeRange)(nil), // 16: transit_realtime.TimeRange + (*Position)(nil), // 17: transit_realtime.Position + (*TripDescriptor)(nil), // 18: transit_realtime.TripDescriptor + (*VehicleDescriptor)(nil), // 19: transit_realtime.VehicleDescriptor + (*EntitySelector)(nil), // 20: transit_realtime.EntitySelector + (*TranslatedString)(nil), // 21: transit_realtime.TranslatedString + (*TranslatedImage)(nil), // 22: transit_realtime.TranslatedImage + (*Shape)(nil), // 23: transit_realtime.Shape + (*TripUpdate_StopTimeEvent)(nil), // 24: transit_realtime.TripUpdate.StopTimeEvent + (*TripUpdate_StopTimeUpdate)(nil), // 25: transit_realtime.TripUpdate.StopTimeUpdate + (*TripUpdate_TripProperties)(nil), // 26: transit_realtime.TripUpdate.TripProperties + (*TripUpdate_StopTimeUpdate_StopTimeProperties)(nil), // 27: transit_realtime.TripUpdate.StopTimeUpdate.StopTimeProperties + (*VehiclePosition_CarriageDetails)(nil), // 28: transit_realtime.VehiclePosition.CarriageDetails + (*TranslatedString_Translation)(nil), // 29: transit_realtime.TranslatedString.Translation + (*TranslatedImage_LocalizedImage)(nil), // 30: transit_realtime.TranslatedImage.LocalizedImage +} +var file_gtfs_realtime_proto_depIdxs = []int32{ + 11, // 0: transit_realtime.FeedMessage.header:type_name -> transit_realtime.FeedHeader + 12, // 1: transit_realtime.FeedMessage.entity:type_name -> transit_realtime.FeedEntity + 0, // 2: transit_realtime.FeedHeader.incrementality:type_name -> transit_realtime.FeedHeader.Incrementality + 13, // 3: transit_realtime.FeedEntity.trip_update:type_name -> transit_realtime.TripUpdate + 14, // 4: transit_realtime.FeedEntity.vehicle:type_name -> transit_realtime.VehiclePosition + 15, // 5: transit_realtime.FeedEntity.alert:type_name -> transit_realtime.Alert + 23, // 6: transit_realtime.FeedEntity.shape:type_name -> transit_realtime.Shape + 18, // 7: transit_realtime.TripUpdate.trip:type_name -> transit_realtime.TripDescriptor + 19, // 8: transit_realtime.TripUpdate.vehicle:type_name -> transit_realtime.VehicleDescriptor + 25, // 9: transit_realtime.TripUpdate.stop_time_update:type_name -> transit_realtime.TripUpdate.StopTimeUpdate + 26, // 10: transit_realtime.TripUpdate.trip_properties:type_name -> transit_realtime.TripUpdate.TripProperties + 18, // 11: transit_realtime.VehiclePosition.trip:type_name -> transit_realtime.TripDescriptor + 19, // 12: transit_realtime.VehiclePosition.vehicle:type_name -> transit_realtime.VehicleDescriptor + 17, // 13: transit_realtime.VehiclePosition.position:type_name -> transit_realtime.Position + 2, // 14: transit_realtime.VehiclePosition.current_status:type_name -> transit_realtime.VehiclePosition.VehicleStopStatus + 3, // 15: transit_realtime.VehiclePosition.congestion_level:type_name -> transit_realtime.VehiclePosition.CongestionLevel + 4, // 16: transit_realtime.VehiclePosition.occupancy_status:type_name -> transit_realtime.VehiclePosition.OccupancyStatus + 28, // 17: transit_realtime.VehiclePosition.multi_carriage_details:type_name -> transit_realtime.VehiclePosition.CarriageDetails + 16, // 18: transit_realtime.Alert.active_period:type_name -> transit_realtime.TimeRange + 20, // 19: transit_realtime.Alert.informed_entity:type_name -> transit_realtime.EntitySelector + 5, // 20: transit_realtime.Alert.cause:type_name -> transit_realtime.Alert.Cause + 6, // 21: transit_realtime.Alert.effect:type_name -> transit_realtime.Alert.Effect + 21, // 22: transit_realtime.Alert.url:type_name -> transit_realtime.TranslatedString + 21, // 23: transit_realtime.Alert.header_text:type_name -> transit_realtime.TranslatedString + 21, // 24: transit_realtime.Alert.description_text:type_name -> transit_realtime.TranslatedString + 21, // 25: transit_realtime.Alert.tts_header_text:type_name -> transit_realtime.TranslatedString + 21, // 26: transit_realtime.Alert.tts_description_text:type_name -> transit_realtime.TranslatedString + 7, // 27: transit_realtime.Alert.severity_level:type_name -> transit_realtime.Alert.SeverityLevel + 22, // 28: transit_realtime.Alert.image:type_name -> transit_realtime.TranslatedImage + 21, // 29: transit_realtime.Alert.image_alternative_text:type_name -> transit_realtime.TranslatedString + 21, // 30: transit_realtime.Alert.cause_detail:type_name -> transit_realtime.TranslatedString + 21, // 31: transit_realtime.Alert.effect_detail:type_name -> transit_realtime.TranslatedString + 8, // 32: transit_realtime.TripDescriptor.schedule_relationship:type_name -> transit_realtime.TripDescriptor.ScheduleRelationship + 9, // 33: transit_realtime.VehicleDescriptor.wheelchair_accessible:type_name -> transit_realtime.VehicleDescriptor.WheelchairAccessible + 18, // 34: transit_realtime.EntitySelector.trip:type_name -> transit_realtime.TripDescriptor + 29, // 35: transit_realtime.TranslatedString.translation:type_name -> transit_realtime.TranslatedString.Translation + 30, // 36: transit_realtime.TranslatedImage.localized_image:type_name -> transit_realtime.TranslatedImage.LocalizedImage + 24, // 37: transit_realtime.TripUpdate.StopTimeUpdate.arrival:type_name -> transit_realtime.TripUpdate.StopTimeEvent + 24, // 38: transit_realtime.TripUpdate.StopTimeUpdate.departure:type_name -> transit_realtime.TripUpdate.StopTimeEvent + 4, // 39: transit_realtime.TripUpdate.StopTimeUpdate.departure_occupancy_status:type_name -> transit_realtime.VehiclePosition.OccupancyStatus + 1, // 40: transit_realtime.TripUpdate.StopTimeUpdate.schedule_relationship:type_name -> transit_realtime.TripUpdate.StopTimeUpdate.ScheduleRelationship + 27, // 41: transit_realtime.TripUpdate.StopTimeUpdate.stop_time_properties:type_name -> transit_realtime.TripUpdate.StopTimeUpdate.StopTimeProperties + 4, // 42: transit_realtime.VehiclePosition.CarriageDetails.occupancy_status:type_name -> transit_realtime.VehiclePosition.OccupancyStatus + 43, // [43:43] is the sub-list for method output_type + 43, // [43:43] is the sub-list for method input_type + 43, // [43:43] is the sub-list for extension type_name + 43, // [43:43] is the sub-list for extension extendee + 0, // [0:43] is the sub-list for field type_name +} + +func init() { file_gtfs_realtime_proto_init() } +func file_gtfs_realtime_proto_init() { + if File_gtfs_realtime_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_gtfs_realtime_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FeedMessage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FeedHeader); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FeedEntity); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TripUpdate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VehiclePosition); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Alert); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TimeRange); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Position); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TripDescriptor); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VehicleDescriptor); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*EntitySelector); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TranslatedString); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TranslatedImage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Shape); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TripUpdate_StopTimeEvent); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TripUpdate_StopTimeUpdate); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TripUpdate_TripProperties); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TripUpdate_StopTimeUpdate_StopTimeProperties); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*VehiclePosition_CarriageDetails); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TranslatedString_Translation); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_gtfs_realtime_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*TranslatedImage_LocalizedImage); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_gtfs_realtime_proto_rawDesc, + NumEnums: 10, + NumMessages: 21, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_gtfs_realtime_proto_goTypes, + DependencyIndexes: file_gtfs_realtime_proto_depIdxs, + EnumInfos: file_gtfs_realtime_proto_enumTypes, + MessageInfos: file_gtfs_realtime_proto_msgTypes, + }.Build() + File_gtfs_realtime_proto = out.File + file_gtfs_realtime_proto_rawDesc = nil + file_gtfs_realtime_proto_goTypes = nil + file_gtfs_realtime_proto_depIdxs = nil +} diff --git a/proto/gtfs-realtime.proto b/proto/gtfs-realtime.proto new file mode 100644 index 0000000..bcd7d88 --- /dev/null +++ b/proto/gtfs-realtime.proto @@ -0,0 +1,1035 @@ +// Copyright 2015 The GTFS Specifications Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Protocol definition file for GTFS Realtime. +// +// GTFS Realtime lets transit agencies provide consumers with realtime +// information about disruptions to their service (stations closed, lines not +// operating, important delays etc), location of their vehicles and expected +// arrival times. +// +// This protocol is published at: +// https://github.com/google/transit/tree/master/gtfs-realtime + +syntax = "proto2"; +option java_package = "com.google.transit.realtime"; +package transit_realtime; + +// The contents of a feed message. +// A feed is a continuous stream of feed messages. Each message in the stream is +// obtained as a response to an appropriate HTTP GET request. +// A realtime feed is always defined with relation to an existing GTFS feed. +// All the entity ids are resolved with respect to the GTFS feed. +// Note that "required" and "optional" as stated in this file refer to Protocol +// Buffer cardinality, not semantic cardinality. See reference.md at +// https://github.com/google/transit/tree/master/gtfs-realtime for field +// semantic cardinality. +message FeedMessage { + // Metadata about this feed and feed message. + required FeedHeader header = 1; + + // Contents of the feed. + repeated FeedEntity entity = 2; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// Metadata about a feed, included in feed messages. +message FeedHeader { + // Version of the feed specification. + // The current version is 2.0. Valid versions are "2.0", "1.0". + required string gtfs_realtime_version = 1; + + // Determines whether the current fetch is incremental. Currently, + // DIFFERENTIAL mode is unsupported and behavior is unspecified for feeds + // that use this mode. There are discussions on the GTFS Realtime mailing + // list around fully specifying the behavior of DIFFERENTIAL mode and the + // documentation will be updated when those discussions are finalized. + enum Incrementality { + FULL_DATASET = 0; + DIFFERENTIAL = 1; + } + optional Incrementality incrementality = 2 [default = FULL_DATASET]; + + // This timestamp identifies the moment when the content of this feed has been + // created (in server time). In POSIX time (i.e., number of seconds since + // January 1st 1970 00:00:00 UTC). + optional uint64 timestamp = 3; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// A definition (or update) of an entity in the transit feed. +message FeedEntity { + // The ids are used only to provide incrementality support. The id should be + // unique within a FeedMessage. Consequent FeedMessages may contain + // FeedEntities with the same id. In case of a DIFFERENTIAL update the new + // FeedEntity with some id will replace the old FeedEntity with the same id + // (or delete it - see is_deleted below). + // The actual GTFS entities (e.g. stations, routes, trips) referenced by the + // feed must be specified by explicit selectors (see EntitySelector below for + // more info). + required string id = 1; + + // Whether this entity is to be deleted. Relevant only for incremental + // fetches. + optional bool is_deleted = 2 [default = false]; + + // Data about the entity itself. Exactly one of the following fields must be + // present (unless the entity is being deleted). + optional TripUpdate trip_update = 3; + optional VehiclePosition vehicle = 4; + optional Alert alert = 5; + + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional Shape shape = 6; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// +// Entities used in the feed. +// + +// Realtime update of the progress of a vehicle along a trip. +// Depending on the value of ScheduleRelationship, a TripUpdate can specify: +// - A trip that proceeds along the schedule. +// - A trip that proceeds along a route but has no fixed schedule. +// - A trip that have been added or removed with regard to schedule. +// +// The updates can be for future, predicted arrival/departure events, or for +// past events that already occurred. +// Normally, updates should get more precise and more certain (see +// uncertainty below) as the events gets closer to current time. +// Even if that is not possible, the information for past events should be +// precise and certain. In particular, if an update points to time in the past +// but its update's uncertainty is not 0, the client should conclude that the +// update is a (wrong) prediction and that the trip has not completed yet. +// +// Note that the update can describe a trip that is already completed. +// To this end, it is enough to provide an update for the last stop of the trip. +// If the time of that is in the past, the client will conclude from that that +// the whole trip is in the past (it is possible, although inconsequential, to +// also provide updates for preceding stops). +// This option is most relevant for a trip that has completed ahead of schedule, +// but according to the schedule, the trip is still proceeding at the current +// time. Removing the updates for this trip could make the client assume +// that the trip is still proceeding. +// Note that the feed provider is allowed, but not required, to purge past +// updates - this is one case where this would be practically useful. +message TripUpdate { + // The Trip that this message applies to. There can be at most one + // TripUpdate entity for each actual trip instance. + // If there is none, that means there is no prediction information available. + // It does *not* mean that the trip is progressing according to schedule. + required TripDescriptor trip = 1; + + // Additional information on the vehicle that is serving this trip. + optional VehicleDescriptor vehicle = 3; + + // Timing information for a single predicted event (either arrival or + // departure). + // Timing consists of delay and/or estimated time, and uncertainty. + // - delay should be used when the prediction is given relative to some + // existing schedule in GTFS. + // - time should be given whether there is a predicted schedule or not. If + // both time and delay are specified, time will take precedence + // (although normally, time, if given for a scheduled trip, should be + // equal to scheduled time in GTFS + delay). + // + // Uncertainty applies equally to both time and delay. + // The uncertainty roughly specifies the expected error in true delay (but + // note, we don't yet define its precise statistical meaning). It's possible + // for the uncertainty to be 0, for example for trains that are driven under + // computer timing control. + message StopTimeEvent { + // Delay (in seconds) can be positive (meaning that the vehicle is late) or + // negative (meaning that the vehicle is ahead of schedule). Delay of 0 + // means that the vehicle is exactly on time. + optional int32 delay = 1; + + // Event as absolute time. + // In Unix time (i.e., number of seconds since January 1st 1970 00:00:00 + // UTC). + optional int64 time = 2; + + // If uncertainty is omitted, it is interpreted as unknown. + // If the prediction is unknown or too uncertain, the delay (or time) field + // should be empty. In such case, the uncertainty field is ignored. + // To specify a completely certain prediction, set its uncertainty to 0. + optional int32 uncertainty = 3; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features + // and modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; + } + + // Realtime update for arrival and/or departure events for a given stop on a + // trip. Updates can be supplied for both past and future events. + // The producer is allowed, although not required, to drop past events. + message StopTimeUpdate { + // The update is linked to a specific stop either through stop_sequence or + // stop_id, so one of the fields below must necessarily be set. + // See the documentation in TripDescriptor for more information. + + // Must be the same as in stop_times.txt in the corresponding GTFS feed. + optional uint32 stop_sequence = 1; + // Must be the same as in stops.txt in the corresponding GTFS feed. + optional string stop_id = 4; + + optional StopTimeEvent arrival = 2; + optional StopTimeEvent departure = 3; + + // Expected occupancy after departure from the given stop. + // Should be provided only for future stops. + // In order to provide departure_occupancy_status without either arrival or + // departure StopTimeEvents, ScheduleRelationship should be set to NO_DATA. + optional VehiclePosition.OccupancyStatus departure_occupancy_status = 7; + + // The relation between the StopTimeEvents and the static schedule. + enum ScheduleRelationship { + // The vehicle is proceeding in accordance with its static schedule of + // stops, although not necessarily according to the times of the schedule. + // At least one of arrival and departure must be provided. If the schedule + // for this stop contains both arrival and departure times then so must + // this update. Frequency-based trips (GTFS frequencies.txt with exact_times = 0) + // should not have a SCHEDULED value and should use UNSCHEDULED instead. + SCHEDULED = 0; + + // The stop is skipped, i.e., the vehicle will not stop at this stop. + // Arrival and departure are optional. + SKIPPED = 1; + + // No StopTimeEvents are given for this stop. + // The main intention for this value is to give time predictions only for + // part of a trip, i.e., if the last update for a trip has a NO_DATA + // specifier, then StopTimeEvents for the rest of the stops in the trip + // are considered to be unspecified as well. + // Neither arrival nor departure should be supplied. + NO_DATA = 2; + + // The vehicle is operating a trip defined in GTFS frequencies.txt with exact_times = 0. + // This value should not be used for trips that are not defined in GTFS frequencies.txt, + // or trips in GTFS frequencies.txt with exact_times = 1. Trips containing StopTimeUpdates + // with ScheduleRelationship=UNSCHEDULED must also set TripDescriptor.ScheduleRelationship=UNSCHEDULED. + // NOTE: This field is still experimental, and subject to change. It may be + // formally adopted in the future. + UNSCHEDULED = 3; + } + optional ScheduleRelationship schedule_relationship = 5 + [default = SCHEDULED]; + + // Provides the updated values for the stop time. + // NOTE: This message is still experimental, and subject to change. It may be formally adopted in the future. + message StopTimeProperties { + // Supports real-time stop assignments. Refers to a stop_id defined in the GTFS stops.txt. + // The new assigned_stop_id should not result in a significantly different trip experience for the end user than + // the stop_id defined in GTFS stop_times.txt. In other words, the end user should not view this new stop_id as an + // "unusual change" if the new stop was presented within an app without any additional context. + // For example, this field is intended to be used for platform assignments by using a stop_id that belongs to the + // same station as the stop originally defined in GTFS stop_times.txt. + // To assign a stop without providing any real-time arrival or departure predictions, populate this field and set + // StopTimeUpdate.schedule_relationship = NO_DATA. + // If this field is populated, it is preferred to omit `StopTimeUpdate.stop_id` and use only `StopTimeUpdate.stop_sequence`. If + // `StopTimeProperties.assigned_stop_id` and `StopTimeUpdate.stop_id` are populated, `StopTimeUpdate.stop_id` must match `assigned_stop_id`. + // Platform assignments should be reflected in other GTFS-realtime fields as well + // (e.g., `VehiclePosition.stop_id`). + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional string assigned_stop_id = 1; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features + // and modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; + } + + // Realtime updates for certain properties defined within GTFS stop_times.txt + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional StopTimeProperties stop_time_properties = 6; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features + // and modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; + } + + // Updates to StopTimes for the trip (both future, i.e., predictions, and in + // some cases, past ones, i.e., those that already happened). + // The updates must be sorted by stop_sequence, and apply for all the + // following stops of the trip up to the next specified one. + // + // Example 1: + // For a trip with 20 stops, a StopTimeUpdate with arrival delay and departure + // delay of 0 for stop_sequence of the current stop means that the trip is + // exactly on time. + // + // Example 2: + // For the same trip instance, 3 StopTimeUpdates are provided: + // - delay of 5 min for stop_sequence 3 + // - delay of 1 min for stop_sequence 8 + // - delay of unspecified duration for stop_sequence 10 + // This will be interpreted as: + // - stop_sequences 3,4,5,6,7 have delay of 5 min. + // - stop_sequences 8,9 have delay of 1 min. + // - stop_sequences 10,... have unknown delay. + repeated StopTimeUpdate stop_time_update = 2; + + // The most recent moment at which the vehicle's real-time progress was measured + // to estimate StopTimes in the future. When StopTimes in the past are provided, + // arrival/departure times may be earlier than this value. In POSIX + // time (i.e., the number of seconds since January 1st 1970 00:00:00 UTC). + optional uint64 timestamp = 4; + + // The current schedule deviation for the trip. Delay should only be + // specified when the prediction is given relative to some existing schedule + // in GTFS. + // + // Delay (in seconds) can be positive (meaning that the vehicle is late) or + // negative (meaning that the vehicle is ahead of schedule). Delay of 0 + // means that the vehicle is exactly on time. + // + // Delay information in StopTimeUpdates take precedent of trip-level delay + // information, such that trip-level delay is only propagated until the next + // stop along the trip with a StopTimeUpdate delay value specified. + // + // Feed providers are strongly encouraged to provide a TripUpdate.timestamp + // value indicating when the delay value was last updated, in order to + // evaluate the freshness of the data. + // + // NOTE: This field is still experimental, and subject to change. It may be + // formally adopted in the future. + optional int32 delay = 5; + + // Defines updated properties of the trip, such as a new shape_id when there is a detour. Or defines the + // trip_id, start_date, and start_time of a DUPLICATED trip. + // NOTE: This message is still experimental, and subject to change. It may be formally adopted in the future. + message TripProperties { + // Defines the identifier of a new trip that is a duplicate of an existing trip defined in (CSV) GTFS trips.txt + // but will start at a different service date and/or time (defined using the TripProperties.start_date and + // TripProperties.start_time fields). See definition of trips.trip_id in (CSV) GTFS. Its value must be different + // than the ones used in the (CSV) GTFS. Required if schedule_relationship=DUPLICATED, otherwise this field must not + // be populated and will be ignored by consumers. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional string trip_id = 1; + // Service date on which the DUPLICATED trip will be run, in YYYYMMDD format. Required if + // schedule_relationship=DUPLICATED, otherwise this field must not be populated and will be ignored by consumers. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional string start_date = 2; + // Defines the departure start time of the trip when it’s duplicated. See definition of stop_times.departure_time + // in (CSV) GTFS. Scheduled arrival and departure times for the duplicated trip are calculated based on the offset + // between the original trip departure_time and this field. For example, if a GTFS trip has stop A with a + // departure_time of 10:00:00 and stop B with departure_time of 10:01:00, and this field is populated with the value + // of 10:30:00, stop B on the duplicated trip will have a scheduled departure_time of 10:31:00. Real-time prediction + // delay values are applied to this calculated schedule time to determine the predicted time. For example, if a + // departure delay of 30 is provided for stop B, then the predicted departure time is 10:31:30. Real-time + // prediction time values do not have any offset applied to them and indicate the predicted time as provided. + // For example, if a departure time representing 10:31:30 is provided for stop B, then the predicted departure time + // is 10:31:30. This field is required if schedule_relationship is DUPLICATED, otherwise this field must not be + // populated and will be ignored by consumers. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional string start_time = 3; + // Specifies the shape of the vehicle travel path when the trip shape differs from the shape specified in + // (CSV) GTFS or to specify it in real-time when it's not provided by (CSV) GTFS, such as a vehicle that takes differing + // paths based on rider demand. See definition of trips.shape_id in (CSV) GTFS. If a shape is neither defined in (CSV) GTFS + // nor in real-time, the shape is considered unknown. This field can refer to a shape defined in the (CSV) GTFS in shapes.txt + // or a Shape in the (protobuf) real-time feed. The order of stops (stop sequences) for this trip must remain the same as + // (CSV) GTFS. Stops that are a part of the original trip but will no longer be made, such as when a detour occurs, should + // be marked as schedule_relationship=SKIPPED. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional string shape_id = 4; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features + // and modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; + } + optional TripProperties trip_properties = 6; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// Realtime positioning information for a given vehicle. +message VehiclePosition { + // The Trip that this vehicle is serving. + // Can be empty or partial if the vehicle can not be identified with a given + // trip instance. + optional TripDescriptor trip = 1; + + // Additional information on the vehicle that is serving this trip. + optional VehicleDescriptor vehicle = 8; + + // Current position of this vehicle. + optional Position position = 2; + + // The stop sequence index of the current stop. The meaning of + // current_stop_sequence (i.e., the stop that it refers to) is determined by + // current_status. + // If current_status is missing IN_TRANSIT_TO is assumed. + optional uint32 current_stop_sequence = 3; + // Identifies the current stop. The value must be the same as in stops.txt in + // the corresponding GTFS feed. + optional string stop_id = 7; + + enum VehicleStopStatus { + // The vehicle is just about to arrive at the stop (on a stop + // display, the vehicle symbol typically flashes). + INCOMING_AT = 0; + + // The vehicle is standing at the stop. + STOPPED_AT = 1; + + // The vehicle has departed and is in transit to the next stop. + IN_TRANSIT_TO = 2; + } + // The exact status of the vehicle with respect to the current stop. + // Ignored if current_stop_sequence is missing. + optional VehicleStopStatus current_status = 4 [default = IN_TRANSIT_TO]; + + // Moment at which the vehicle's position was measured. In POSIX time + // (i.e., number of seconds since January 1st 1970 00:00:00 UTC). + optional uint64 timestamp = 5; + + // Congestion level that is affecting this vehicle. + enum CongestionLevel { + UNKNOWN_CONGESTION_LEVEL = 0; + RUNNING_SMOOTHLY = 1; + STOP_AND_GO = 2; + CONGESTION = 3; + SEVERE_CONGESTION = 4; // People leaving their cars. + } + optional CongestionLevel congestion_level = 6; + + // The state of passenger occupancy for the vehicle or carriage. + // Individual producers may not publish all OccupancyStatus values. Therefore, consumers + // must not assume that the OccupancyStatus values follow a linear scale. + // Consumers should represent OccupancyStatus values as the state indicated + // and intended by the producer. Likewise, producers must use OccupancyStatus values that + // correspond to actual vehicle occupancy states. + // For describing passenger occupancy levels on a linear scale, see `occupancy_percentage`. + // This field is still experimental, and subject to change. It may be formally adopted in the future. + enum OccupancyStatus { + // The vehicle or carriage is considered empty by most measures, and has few or no + // passengers onboard, but is still accepting passengers. + EMPTY = 0; + + // The vehicle or carriage has a large number of seats available. + // The amount of free seats out of the total seats available to be + // considered large enough to fall into this category is determined at the + // discretion of the producer. + MANY_SEATS_AVAILABLE = 1; + + // The vehicle or carriage has a relatively small number of seats available. + // The amount of free seats out of the total seats available to be + // considered small enough to fall into this category is determined at the + // discretion of the feed producer. + FEW_SEATS_AVAILABLE = 2; + + // The vehicle or carriage can currently accommodate only standing passengers. + STANDING_ROOM_ONLY = 3; + + // The vehicle or carriage can currently accommodate only standing passengers + // and has limited space for them. + CRUSHED_STANDING_ROOM_ONLY = 4; + + // The vehicle or carriage is considered full by most measures, but may still be + // allowing passengers to board. + FULL = 5; + + // The vehicle or carriage is not accepting passengers, but usually accepts passengers for boarding. + NOT_ACCEPTING_PASSENGERS = 6; + + // The vehicle or carriage doesn't have any occupancy data available at that time. + NO_DATA_AVAILABLE = 7; + + // The vehicle or carriage is not boardable and never accepts passengers. + // Useful for special vehicles or carriages (engine, maintenance carriage, etc…). + NOT_BOARDABLE = 8; + + } + // If multi_carriage_status is populated with per-carriage OccupancyStatus, + // then this field should describe the entire vehicle with all carriages accepting passengers considered. + optional OccupancyStatus occupancy_status = 9; + + // A percentage value indicating the degree of passenger occupancy in the vehicle. + // The values are represented as an integer without decimals. 0 means 0% and 100 means 100%. + // The value 100 should represent the total maximum occupancy the vehicle was designed for, + // including both seated and standing capacity, and current operating regulations allow. + // The value may exceed 100 if there are more passengers than the maximum designed capacity. + // The precision of occupancy_percentage should be low enough that individual passengers cannot be tracked boarding or alighting the vehicle. + // If multi_carriage_status is populated with per-carriage occupancy_percentage, + // then this field should describe the entire vehicle with all carriages accepting passengers considered. + // This field is still experimental, and subject to change. It may be formally adopted in the future. + optional uint32 occupancy_percentage = 10; + + // Carriage specific details, used for vehicles composed of several carriages + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + message CarriageDetails { + + // Identification of the carriage. Should be unique per vehicle. + optional string id = 1; + + // User visible label that may be shown to the passenger to help identify + // the carriage. Example: "7712", "Car ABC-32", etc... + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + optional string label = 2; + + // Occupancy status for this given carriage, in this vehicle + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + optional OccupancyStatus occupancy_status = 3 [default = NO_DATA_AVAILABLE]; + + // Occupancy percentage for this given carriage, in this vehicle. + // Follows the same rules as "VehiclePosition.occupancy_percentage" + // -1 in case data is not available for this given carriage (as protobuf defaults to 0 otherwise) + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + optional int32 occupancy_percentage = 4 [default = -1]; + + // Identifies the order of this carriage with respect to the other + // carriages in the vehicle's list of CarriageDetails. + // The first carriage in the direction of travel must have a value of 1. + // The second value corresponds to the second carriage in the direction + // of travel and must have a value of 2, and so forth. + // For example, the first carriage in the direction of travel has a value of 1. + // If the second carriage in the direction of travel has a value of 3, + // consumers will discard data for all carriages (i.e., the multi_carriage_details field). + // Carriages without data must be represented with a valid carriage_sequence number and the fields + // without data should be omitted (alternately, those fields could also be included and set to the "no data" values). + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + optional uint32 carriage_sequence = 5; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; + } + + // Details of the multiple carriages of this given vehicle. + // The first occurrence represents the first carriage of the vehicle, + // given the current direction of travel. + // The number of occurrences of the multi_carriage_details + // field represents the number of carriages of the vehicle. + // It also includes non boardable carriages, + // like engines, maintenance carriages, etc… as they provide valuable + // information to passengers about where to stand on a platform. + // This message/field is still experimental, and subject to change. It may be formally adopted in the future. + repeated CarriageDetails multi_carriage_details = 11; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// An alert, indicating some sort of incident in the public transit network. +message Alert { + // Time when the alert should be shown to the user. If missing, the + // alert will be shown as long as it appears in the feed. + // If multiple ranges are given, the alert will be shown during all of them. + repeated TimeRange active_period = 1; + + // Entities whose users we should notify of this alert. + repeated EntitySelector informed_entity = 5; + + // Cause of this alert. If cause_detail is included, then Cause must also be included. + enum Cause { + UNKNOWN_CAUSE = 1; + OTHER_CAUSE = 2; // Not machine-representable. + TECHNICAL_PROBLEM = 3; + STRIKE = 4; // Public transit agency employees stopped working. + DEMONSTRATION = 5; // People are blocking the streets. + ACCIDENT = 6; + HOLIDAY = 7; + WEATHER = 8; + MAINTENANCE = 9; + CONSTRUCTION = 10; + POLICE_ACTIVITY = 11; + MEDICAL_EMERGENCY = 12; + } + optional Cause cause = 6 [default = UNKNOWN_CAUSE]; + + // What is the effect of this problem on the affected entity. If effect_detail is included, then Effect must also be included. + enum Effect { + NO_SERVICE = 1; + REDUCED_SERVICE = 2; + + // We don't care about INsignificant delays: they are hard to detect, have + // little impact on the user, and would clutter the results as they are too + // frequent. + SIGNIFICANT_DELAYS = 3; + + DETOUR = 4; + ADDITIONAL_SERVICE = 5; + MODIFIED_SERVICE = 6; + OTHER_EFFECT = 7; + UNKNOWN_EFFECT = 8; + STOP_MOVED = 9; + NO_EFFECT = 10; + ACCESSIBILITY_ISSUE = 11; + } + optional Effect effect = 7 [default = UNKNOWN_EFFECT]; + + // The URL which provides additional information about the alert. + optional TranslatedString url = 8; + + // Alert header. Contains a short summary of the alert text as plain-text. + optional TranslatedString header_text = 10; + + // Full description for the alert as plain-text. The information in the + // description should add to the information of the header. + optional TranslatedString description_text = 11; + + // Text for alert header to be used in text-to-speech implementations. This field is the text-to-speech version of header_text. + optional TranslatedString tts_header_text = 12; + + // Text for full description for the alert to be used in text-to-speech implementations. This field is the text-to-speech version of description_text. + optional TranslatedString tts_description_text = 13; + + // Severity of this alert. + enum SeverityLevel { + UNKNOWN_SEVERITY = 1; + INFO = 2; + WARNING = 3; + SEVERE = 4; + } + + optional SeverityLevel severity_level = 14 [default = UNKNOWN_SEVERITY]; + + // TranslatedImage to be displayed along the alert text. Used to explain visually the alert effect of a detour, station closure, etc. The image must enhance the understanding of the alert. Any essential information communicated within the image must also be contained in the alert text. + // The following types of images are discouraged : image containing mainly text, marketing or branded images that add no additional information. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional TranslatedImage image = 15; + + // Text describing the appearance of the linked image in the `image` field (e.g., in case the image can't be displayed + // or the user can't see the image for accessibility reasons). See the HTML spec for alt image text - https://html.spec.whatwg.org/#alt. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional TranslatedString image_alternative_text = 16; + + + // Description of the cause of the alert that allows for agency-specific language; more specific than the Cause. If cause_detail is included, then Cause must also be included. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional TranslatedString cause_detail = 17; + + // Description of the effect of the alert that allows for agency-specific language; more specific than the Effect. If effect_detail is included, then Effect must also be included. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional TranslatedString effect_detail = 18; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features + // and modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// +// Low level data structures used above. +// + +// A time interval. The interval is considered active at time 't' if 't' is +// greater than or equal to the start time and less than the end time. +message TimeRange { + // Start time, in POSIX time (i.e., number of seconds since January 1st 1970 + // 00:00:00 UTC). + // If missing, the interval starts at minus infinity. + optional uint64 start = 1; + + // End time, in POSIX time (i.e., number of seconds since January 1st 1970 + // 00:00:00 UTC). + // If missing, the interval ends at plus infinity. + optional uint64 end = 2; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// A position. +message Position { + // Degrees North, in the WGS-84 coordinate system. + required float latitude = 1; + + // Degrees East, in the WGS-84 coordinate system. + required float longitude = 2; + + // Bearing, in degrees, clockwise from North, i.e., 0 is North and 90 is East. + // This can be the compass bearing, or the direction towards the next stop + // or intermediate location. + // This should not be direction deduced from the sequence of previous + // positions, which can be computed from previous data. + optional float bearing = 3; + + // Odometer value, in meters. + optional double odometer = 4; + // Momentary speed measured by the vehicle, in meters per second. + optional float speed = 5; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// A descriptor that identifies an instance of a GTFS trip, or all instances of +// a trip along a route. +// - To specify a single trip instance, the trip_id (and if necessary, +// start_time) is set. If route_id is also set, then it should be same as one +// that the given trip corresponds to. +// - To specify all the trips along a given route, only the route_id should be +// set. Note that if the trip_id is not known, then stop sequence ids in +// TripUpdate are not sufficient, and stop_ids must be provided as well. In +// addition, absolute arrival/departure times must be provided. +message TripDescriptor { + // The trip_id from the GTFS feed that this selector refers to. + // For non frequency-based trips, this field is enough to uniquely identify + // the trip. For frequency-based trip, start_time and start_date might also be + // necessary. When schedule_relationship is DUPLICATED within a TripUpdate, the trip_id identifies the trip from + // static GTFS to be duplicated. When schedule_relationship is DUPLICATED within a VehiclePosition, the trip_id + // identifies the new duplicate trip and must contain the value for the corresponding TripUpdate.TripProperties.trip_id. + optional string trip_id = 1; + + // The route_id from the GTFS that this selector refers to. + optional string route_id = 5; + + // The direction_id from the GTFS feed trips.txt file, indicating the + // direction of travel for trips this selector refers to. + optional uint32 direction_id = 6; + + // The initially scheduled start time of this trip instance. + // When the trip_id corresponds to a non-frequency-based trip, this field + // should either be omitted or be equal to the value in the GTFS feed. When + // the trip_id correponds to a frequency-based trip, the start_time must be + // specified for trip updates and vehicle positions. If the trip corresponds + // to exact_times=1 GTFS record, then start_time must be some multiple + // (including zero) of headway_secs later than frequencies.txt start_time for + // the corresponding time period. If the trip corresponds to exact_times=0, + // then its start_time may be arbitrary, and is initially expected to be the + // first departure of the trip. Once established, the start_time of this + // frequency-based trip should be considered immutable, even if the first + // departure time changes -- that time change may instead be reflected in a + // StopTimeUpdate. + // Format and semantics of the field is same as that of + // GTFS/frequencies.txt/start_time, e.g., 11:15:35 or 25:15:35. + optional string start_time = 2; + // The scheduled start date of this trip instance. + // Must be provided to disambiguate trips that are so late as to collide with + // a scheduled trip on a next day. For example, for a train that departs 8:00 + // and 20:00 every day, and is 12 hours late, there would be two distinct + // trips on the same time. + // This field can be provided but is not mandatory for schedules in which such + // collisions are impossible - for example, a service running on hourly + // schedule where a vehicle that is one hour late is not considered to be + // related to schedule anymore. + // In YYYYMMDD format. + optional string start_date = 3; + + // The relation between this trip and the static schedule. If a trip is done + // in accordance with temporary schedule, not reflected in GTFS, then it + // shouldn't be marked as SCHEDULED, but likely as ADDED. + enum ScheduleRelationship { + // Trip that is running in accordance with its GTFS schedule, or is close + // enough to the scheduled trip to be associated with it. + SCHEDULED = 0; + + // An extra trip that was added in addition to a running schedule, for + // example, to replace a broken vehicle or to respond to sudden passenger + // load. + // NOTE: Currently, behavior is unspecified for feeds that use this mode. There are discussions on the GTFS GitHub + // [(1)](https://github.com/google/transit/issues/106) [(2)](https://github.com/google/transit/pull/221) + // [(3)](https://github.com/google/transit/pull/219) around fully specifying or deprecating ADDED trips and the + // documentation will be updated when those discussions are finalized. + ADDED = 1; + + // A trip that is running with no schedule associated to it (GTFS frequencies.txt exact_times=0). + // Trips with ScheduleRelationship=UNSCHEDULED must also set all StopTimeUpdates.ScheduleRelationship=UNSCHEDULED. + UNSCHEDULED = 2; + + // A trip that existed in the schedule but was removed. + CANCELED = 3; + + // Should not be used - for backwards-compatibility only. + REPLACEMENT = 5 [deprecated=true]; + + // An extra trip that was added in addition to a running schedule, for example, to replace a broken vehicle or to + // respond to sudden passenger load. Used with TripUpdate.TripProperties.trip_id, TripUpdate.TripProperties.start_date, + // and TripUpdate.TripProperties.start_time to copy an existing trip from static GTFS but start at a different service + // date and/or time. Duplicating a trip is allowed if the service related to the original trip in (CSV) GTFS + // (in calendar.txt or calendar_dates.txt) is operating within the next 30 days. The trip to be duplicated is + // identified via TripUpdate.TripDescriptor.trip_id. This enumeration does not modify the existing trip referenced by + // TripUpdate.TripDescriptor.trip_id - if a producer wants to cancel the original trip, it must publish a separate + // TripUpdate with the value of CANCELED or DELETED. Trips defined in GTFS frequencies.txt with exact_times that is + // empty or equal to 0 cannot be duplicated. The VehiclePosition.TripDescriptor.trip_id for the new trip must contain + // the matching value from TripUpdate.TripProperties.trip_id and VehiclePosition.TripDescriptor.ScheduleRelationship + // must also be set to DUPLICATED. + // Existing producers and consumers that were using the ADDED enumeration to represent duplicated trips must follow + // the migration guide (https://github.com/google/transit/tree/master/gtfs-realtime/spec/en/examples/migration-duplicated.md) + // to transition to the DUPLICATED enumeration. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + DUPLICATED = 6; + + + // A trip that existed in the schedule but was removed and must not be shown to users. + // DELETED should be used instead of CANCELED to indicate that a transit provider would like to entirely remove + // information about the corresponding trip from consuming applications, so the trip is not shown as cancelled to + // riders, e.g. a trip that is entirely being replaced by another trip. + // This designation becomes particularly important if several trips are cancelled and replaced with substitute service. + // If consumers were to show explicit information about the cancellations it would distract from the more important + // real-time predictions. + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + DELETED = 7; + } + optional ScheduleRelationship schedule_relationship = 4; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// Identification information for the vehicle performing the trip. +message VehicleDescriptor { + // Internal system identification of the vehicle. Should be unique per + // vehicle, and can be used for tracking the vehicle as it proceeds through + // the system. + optional string id = 1; + + // User visible label, i.e., something that must be shown to the passenger to + // help identify the correct vehicle. + optional string label = 2; + + // The license plate of the vehicle. + optional string license_plate = 3; + + enum WheelchairAccessible { + // The trip doesn't have information about wheelchair accessibility. + // This is the **default** behavior. If the static GTFS contains a + // _wheelchair_accessible_ value, it won't be overwritten. + NO_VALUE = 0; + + // The trip has no accessibility value present. + // This value will overwrite the value from the GTFS. + UNKNOWN = 1; + + // The trip is wheelchair accessible. + // This value will overwrite the value from the GTFS. + WHEELCHAIR_ACCESSIBLE = 2; + + // The trip is **not** wheelchair accessible. + // This value will overwrite the value from the GTFS. + WHEELCHAIR_INACCESSIBLE = 3; + } + optional WheelchairAccessible wheelchair_accessible = 4 [default = NO_VALUE]; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// A selector for an entity in a GTFS feed. +message EntitySelector { + // The values of the fields should correspond to the appropriate fields in the + // GTFS feed. + // At least one specifier must be given. If several are given, then the + // matching has to apply to all the given specifiers. + optional string agency_id = 1; + optional string route_id = 2; + // corresponds to route_type in GTFS. + optional int32 route_type = 3; + optional TripDescriptor trip = 4; + optional string stop_id = 5; + // Corresponds to trip direction_id in GTFS trips.txt. If provided the + // route_id must also be provided. + optional uint32 direction_id = 6; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// An internationalized message containing per-language versions of a snippet of +// text or a URL. +// One of the strings from a message will be picked up. The resolution proceeds +// as follows: +// 1. If the UI language matches the language code of a translation, +// the first matching translation is picked. +// 2. If a default UI language (e.g., English) matches the language code of a +// translation, the first matching translation is picked. +// 3. If some translation has an unspecified language code, that translation is +// picked. +message TranslatedString { + message Translation { + // A UTF-8 string containing the message. + required string text = 1; + // BCP-47 language code. Can be omitted if the language is unknown or if + // no i18n is done at all for the feed. At most one translation is + // allowed to have an unspecified language tag. + optional string language = 2; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; + } + // At least one translation must be provided. + repeated Translation translation = 1; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// An internationalized image containing per-language versions of a URL linking to an image +// along with meta information +// Only one of the images from a message will be retained by consumers. The resolution proceeds +// as follows: +// 1. If the UI language matches the language code of a translation, +// the first matching translation is picked. +// 2. If a default UI language (e.g., English) matches the language code of a +// translation, the first matching translation is picked. +// 3. If some translation has an unspecified language code, that translation is +// picked. +// NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. +message TranslatedImage { + message LocalizedImage { + // String containing an URL linking to an image + // The image linked must be less than 2MB. + // If an image changes in a significant enough way that an update is required on the consumer side, the producer must update the URL to a new one. + // The URL should be a fully qualified URL that includes http:// or https://, and any special characters in the URL must be correctly escaped. See the following http://www.w3.org/Addressing/URL/4_URI_Recommentations.html for a description of how to create fully qualified URL values. + required string url = 1; + + // IANA media type as to specify the type of image to be displayed. + // The type must start with "image/" + required string media_type = 2; + + // BCP-47 language code. Can be omitted if the language is unknown or if + // no i18n is done at all for the feed. At most one translation is + // allowed to have an unspecified language tag. + optional string language = 3; + + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; + } + // At least one localized image must be provided. + repeated LocalizedImage localized_image = 1; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} + +// Describes the physical path that a vehicle takes when it's not part of the (CSV) GTFS, +// such as for a detour. Shapes belong to Trips, and consist of a sequence of shape points. +// Tracing the points in order provides the path of the vehicle. Shapes do not need to intercept +// the location of Stops exactly, but all Stops on a trip should lie within a small distance of +// the shape for that trip, i.e. close to straight line segments connecting the shape points +// NOTE: This message is still experimental, and subject to change. It may be formally adopted in the future. +message Shape { + // Identifier of the shape. Must be different than any shape_id defined in the (CSV) GTFS. + // This field is required as per reference.md, but needs to be specified here optional because "Required is Forever" + // See https://developers.google.com/protocol-buffers/docs/proto#specifying_field_rules + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional string shape_id = 1; + + // Encoded polyline representation of the shape. This polyline must contain at least two points. + // For more information about encoded polylines, see https://developers.google.com/maps/documentation/utilities/polylinealgorithm + // This field is required as per reference.md, but needs to be specified here optional because "Required is Forever" + // See https://developers.google.com/protocol-buffers/docs/proto#specifying_field_rules + // NOTE: This field is still experimental, and subject to change. It may be formally adopted in the future. + optional string encoded_polyline = 2; + + // The extensions namespace allows 3rd-party developers to extend the + // GTFS Realtime Specification in order to add and evaluate new features and + // modifications to the spec. + extensions 1000 to 1999; + + // The following extension IDs are reserved for private use by any organization. + extensions 9000 to 9999; +} diff --git a/proto/protoc.sh b/proto/protoc.sh new file mode 100644 index 0000000..0d852bc --- /dev/null +++ b/proto/protoc.sh @@ -0,0 +1,11 @@ +#!/bin/bash + +set -e + +# I hate protobuf + +protoc \ + --go_out=../proto \ + --go_opt=Mgtfs-realtime.proto=../proto \ + --go_opt=Mgtfs-realtime-NYCT.proto=../proto \ + gtfs-realtime.proto gtfs-realtime-NYCT.proto diff --git a/realtime_test.go b/realtime_test.go index bd0f2fb..d1b428f 100644 --- a/realtime_test.go +++ b/realtime_test.go @@ -6,13 +6,13 @@ import ( "testing" "time" - p "github.com/MobilityData/gtfs-realtime-bindings/golang/gtfs" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" proto "google.golang.org/protobuf/proto" "tidbyt.dev/gtfs" "tidbyt.dev/gtfs/model" + p "tidbyt.dev/gtfs/proto" "tidbyt.dev/gtfs/testutil" )