minotor 11.5.1 → 12.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,6 +1,6 @@
1
1
  // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
2
2
  // versions:
3
- // protoc-gen-ts_proto v2.10.1
3
+ // protoc-gen-ts_proto v2.18.0
4
4
  // protoc v4.23.4
5
5
  // source: src/timetable/proto/v1/timetable.proto
6
6
 
@@ -9,6 +9,8 @@ import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
9
9
 
10
10
  export const protobufPackage = "minotor.timetable.v1";
11
11
 
12
+ export const protobufFileName = "src/timetable/proto/v1/timetable.proto";
13
+
12
14
  export enum TransferType {
13
15
  TRANSFER_TYPE_UNSPECIFIED = 0,
14
16
  TRANSFER_TYPE_RECOMMENDED_TRANSFER_POINT = 1,
@@ -236,60 +238,79 @@ export const Route: MessageFns<Route> = {
236
238
 
237
239
  decode(input: BinaryReader | Uint8Array, length?: number): Route {
238
240
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
239
- const end = length === undefined ? reader.len : reader.pos + length;
240
- const message = createBaseRoute();
241
- while (reader.pos < end) {
242
- const tag = reader.uint32();
243
- switch (tag >>> 3) {
244
- case 1: {
245
- if (tag !== 10) {
246
- break;
247
- }
241
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
242
+ if (previousRecursionDepth >= 100) {
243
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
244
+ }
245
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
246
+ try {
247
+ const end = length === undefined ? reader.len : reader.pos + length;
248
+ const message = createBaseRoute();
249
+ while (reader.pos < end) {
250
+ const tag = reader.uint32();
251
+ switch (tag >>> 3) {
252
+ case 1: {
253
+ if (tag !== 10) {
254
+ break;
255
+ }
248
256
 
249
- message.stopTimes = reader.bytes();
250
- continue;
251
- }
252
- case 2: {
253
- if (tag !== 18) {
254
- break;
257
+ message.stopTimes = reader.bytes();
258
+ continue;
255
259
  }
260
+ case 2: {
261
+ if (tag !== 18) {
262
+ break;
263
+ }
256
264
 
257
- message.pickupDropOffTypes = reader.bytes();
258
- continue;
259
- }
260
- case 3: {
261
- if (tag !== 26) {
262
- break;
265
+ message.pickupDropOffTypes = reader.bytes();
266
+ continue;
263
267
  }
268
+ case 3: {
269
+ if (tag !== 26) {
270
+ break;
271
+ }
264
272
 
265
- message.stops = reader.bytes();
266
- continue;
267
- }
268
- case 4: {
269
- if (tag !== 32) {
270
- break;
273
+ message.stops = reader.bytes();
274
+ continue;
271
275
  }
276
+ case 4: {
277
+ if (tag !== 32) {
278
+ break;
279
+ }
272
280
 
273
- message.serviceRouteId = reader.uint32();
274
- continue;
281
+ message.serviceRouteId = reader.uint32();
282
+ continue;
283
+ }
275
284
  }
285
+ if ((tag & 7) === 4 || tag === 0) {
286
+ break;
287
+ }
288
+ reader.skip(tag & 7);
276
289
  }
277
- if ((tag & 7) === 4 || tag === 0) {
278
- break;
279
- }
280
- reader.skip(tag & 7);
290
+ return message;
291
+ } finally {
292
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
281
293
  }
282
- return message;
283
294
  },
284
295
 
285
296
  fromJSON(object: any): Route {
286
297
  return {
287
- stopTimes: isSet(object.stopTimes) ? bytesFromBase64(object.stopTimes) : new Uint8Array(0),
298
+ stopTimes: isSet(object.stopTimes)
299
+ ? bytesFromBase64(object.stopTimes)
300
+ : isSet(object.stop_times)
301
+ ? bytesFromBase64(object.stop_times)
302
+ : new Uint8Array(0),
288
303
  pickupDropOffTypes: isSet(object.pickupDropOffTypes)
289
304
  ? bytesFromBase64(object.pickupDropOffTypes)
305
+ : isSet(object.pickup_drop_off_types)
306
+ ? bytesFromBase64(object.pickup_drop_off_types)
290
307
  : new Uint8Array(0),
291
308
  stops: isSet(object.stops) ? bytesFromBase64(object.stops) : new Uint8Array(0),
292
- serviceRouteId: isSet(object.serviceRouteId) ? globalThis.Number(object.serviceRouteId) : 0,
309
+ serviceRouteId: isSet(object.serviceRouteId)
310
+ ? globalThis.Number(object.serviceRouteId)
311
+ : isSet(object.service_route_id)
312
+ ? globalThis.Number(object.service_route_id)
313
+ : 0,
293
314
  };
294
315
  },
295
316
 
@@ -343,49 +364,62 @@ export const Transfer: MessageFns<Transfer> = {
343
364
 
344
365
  decode(input: BinaryReader | Uint8Array, length?: number): Transfer {
345
366
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
346
- const end = length === undefined ? reader.len : reader.pos + length;
347
- const message = createBaseTransfer();
348
- while (reader.pos < end) {
349
- const tag = reader.uint32();
350
- switch (tag >>> 3) {
351
- case 1: {
352
- if (tag !== 8) {
353
- break;
354
- }
367
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
368
+ if (previousRecursionDepth >= 100) {
369
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
370
+ }
371
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
372
+ try {
373
+ const end = length === undefined ? reader.len : reader.pos + length;
374
+ const message = createBaseTransfer();
375
+ while (reader.pos < end) {
376
+ const tag = reader.uint32();
377
+ switch (tag >>> 3) {
378
+ case 1: {
379
+ if (tag !== 8) {
380
+ break;
381
+ }
355
382
 
356
- message.destination = reader.uint32();
357
- continue;
358
- }
359
- case 2: {
360
- if (tag !== 16) {
361
- break;
383
+ message.destination = reader.uint32();
384
+ continue;
362
385
  }
386
+ case 2: {
387
+ if (tag !== 16) {
388
+ break;
389
+ }
363
390
 
364
- message.type = reader.int32() as any;
365
- continue;
366
- }
367
- case 3: {
368
- if (tag !== 24) {
369
- break;
391
+ message.type = reader.int32() as any;
392
+ continue;
370
393
  }
394
+ case 3: {
395
+ if (tag !== 24) {
396
+ break;
397
+ }
371
398
 
372
- message.minTransferTime = reader.uint32();
373
- continue;
399
+ message.minTransferTime = reader.uint32();
400
+ continue;
401
+ }
374
402
  }
403
+ if ((tag & 7) === 4 || tag === 0) {
404
+ break;
405
+ }
406
+ reader.skip(tag & 7);
375
407
  }
376
- if ((tag & 7) === 4 || tag === 0) {
377
- break;
378
- }
379
- reader.skip(tag & 7);
408
+ return message;
409
+ } finally {
410
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
380
411
  }
381
- return message;
382
412
  },
383
413
 
384
414
  fromJSON(object: any): Transfer {
385
415
  return {
386
416
  destination: isSet(object.destination) ? globalThis.Number(object.destination) : 0,
387
417
  type: isSet(object.type) ? transferTypeFromJSON(object.type) : 0,
388
- minTransferTime: isSet(object.minTransferTime) ? globalThis.Number(object.minTransferTime) : undefined,
418
+ minTransferTime: isSet(object.minTransferTime)
419
+ ? globalThis.Number(object.minTransferTime)
420
+ : isSet(object.min_transfer_time)
421
+ ? globalThis.Number(object.min_transfer_time)
422
+ : undefined,
389
423
  };
390
424
  },
391
425
 
@@ -435,49 +469,70 @@ export const TripStop: MessageFns<TripStop> = {
435
469
 
436
470
  decode(input: BinaryReader | Uint8Array, length?: number): TripStop {
437
471
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
438
- const end = length === undefined ? reader.len : reader.pos + length;
439
- const message = createBaseTripStop();
440
- while (reader.pos < end) {
441
- const tag = reader.uint32();
442
- switch (tag >>> 3) {
443
- case 1: {
444
- if (tag !== 8) {
445
- break;
446
- }
472
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
473
+ if (previousRecursionDepth >= 100) {
474
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
475
+ }
476
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
477
+ try {
478
+ const end = length === undefined ? reader.len : reader.pos + length;
479
+ const message = createBaseTripStop();
480
+ while (reader.pos < end) {
481
+ const tag = reader.uint32();
482
+ switch (tag >>> 3) {
483
+ case 1: {
484
+ if (tag !== 8) {
485
+ break;
486
+ }
447
487
 
448
- message.stopIndex = reader.uint32();
449
- continue;
450
- }
451
- case 2: {
452
- if (tag !== 16) {
453
- break;
488
+ message.stopIndex = reader.uint32();
489
+ continue;
454
490
  }
491
+ case 2: {
492
+ if (tag !== 16) {
493
+ break;
494
+ }
455
495
 
456
- message.routeId = reader.uint32();
457
- continue;
458
- }
459
- case 3: {
460
- if (tag !== 24) {
461
- break;
496
+ message.routeId = reader.uint32();
497
+ continue;
462
498
  }
499
+ case 3: {
500
+ if (tag !== 24) {
501
+ break;
502
+ }
463
503
 
464
- message.tripIndex = reader.uint32();
465
- continue;
504
+ message.tripIndex = reader.uint32();
505
+ continue;
506
+ }
466
507
  }
508
+ if ((tag & 7) === 4 || tag === 0) {
509
+ break;
510
+ }
511
+ reader.skip(tag & 7);
467
512
  }
468
- if ((tag & 7) === 4 || tag === 0) {
469
- break;
470
- }
471
- reader.skip(tag & 7);
513
+ return message;
514
+ } finally {
515
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
472
516
  }
473
- return message;
474
517
  },
475
518
 
476
519
  fromJSON(object: any): TripStop {
477
520
  return {
478
- stopIndex: isSet(object.stopIndex) ? globalThis.Number(object.stopIndex) : 0,
479
- routeId: isSet(object.routeId) ? globalThis.Number(object.routeId) : 0,
480
- tripIndex: isSet(object.tripIndex) ? globalThis.Number(object.tripIndex) : 0,
521
+ stopIndex: isSet(object.stopIndex)
522
+ ? globalThis.Number(object.stopIndex)
523
+ : isSet(object.stop_index)
524
+ ? globalThis.Number(object.stop_index)
525
+ : 0,
526
+ routeId: isSet(object.routeId)
527
+ ? globalThis.Number(object.routeId)
528
+ : isSet(object.route_id)
529
+ ? globalThis.Number(object.route_id)
530
+ : 0,
531
+ tripIndex: isSet(object.tripIndex)
532
+ ? globalThis.Number(object.tripIndex)
533
+ : isSet(object.trip_index)
534
+ ? globalThis.Number(object.trip_index)
535
+ : 0,
481
536
  };
482
537
  },
483
538
 
@@ -524,34 +579,43 @@ export const TripTransferEntry: MessageFns<TripTransferEntry> = {
524
579
 
525
580
  decode(input: BinaryReader | Uint8Array, length?: number): TripTransferEntry {
526
581
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
527
- const end = length === undefined ? reader.len : reader.pos + length;
528
- const message = createBaseTripTransferEntry();
529
- while (reader.pos < end) {
530
- const tag = reader.uint32();
531
- switch (tag >>> 3) {
532
- case 1: {
533
- if (tag !== 10) {
534
- break;
535
- }
582
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
583
+ if (previousRecursionDepth >= 100) {
584
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
585
+ }
586
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
587
+ try {
588
+ const end = length === undefined ? reader.len : reader.pos + length;
589
+ const message = createBaseTripTransferEntry();
590
+ while (reader.pos < end) {
591
+ const tag = reader.uint32();
592
+ switch (tag >>> 3) {
593
+ case 1: {
594
+ if (tag !== 10) {
595
+ break;
596
+ }
536
597
 
537
- message.origin = TripStop.decode(reader, reader.uint32());
538
- continue;
539
- }
540
- case 2: {
541
- if (tag !== 18) {
542
- break;
598
+ message.origin = TripStop.decode(reader, reader.uint32());
599
+ continue;
543
600
  }
601
+ case 2: {
602
+ if (tag !== 18) {
603
+ break;
604
+ }
544
605
 
545
- message.destinations.push(TripStop.decode(reader, reader.uint32()));
546
- continue;
606
+ message.destinations.push(TripStop.decode(reader, reader.uint32()));
607
+ continue;
608
+ }
547
609
  }
610
+ if ((tag & 7) === 4 || tag === 0) {
611
+ break;
612
+ }
613
+ reader.skip(tag & 7);
548
614
  }
549
- if ((tag & 7) === 4 || tag === 0) {
550
- break;
551
- }
552
- reader.skip(tag & 7);
615
+ return message;
616
+ } finally {
617
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
553
618
  }
554
- return message;
555
619
  },
556
620
 
557
621
  fromJSON(object: any): TripTransferEntry {
@@ -593,11 +657,13 @@ function createBaseStopAdjacency(): StopAdjacency {
593
657
 
594
658
  export const StopAdjacency: MessageFns<StopAdjacency> = {
595
659
  encode(message: StopAdjacency, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
596
- writer.uint32(10).fork();
597
- for (const v of message.routes) {
598
- writer.uint32(v);
660
+ if (message.routes.length !== 0) {
661
+ writer.uint32(10).fork();
662
+ for (const v of message.routes) {
663
+ writer.uint32(v);
664
+ }
665
+ writer.join();
599
666
  }
600
- writer.join();
601
667
  for (const v of message.transfers) {
602
668
  Transfer.encode(v!, writer.uint32(18).fork()).join();
603
669
  }
@@ -606,44 +672,53 @@ export const StopAdjacency: MessageFns<StopAdjacency> = {
606
672
 
607
673
  decode(input: BinaryReader | Uint8Array, length?: number): StopAdjacency {
608
674
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
609
- const end = length === undefined ? reader.len : reader.pos + length;
610
- const message = createBaseStopAdjacency();
611
- while (reader.pos < end) {
612
- const tag = reader.uint32();
613
- switch (tag >>> 3) {
614
- case 1: {
615
- if (tag === 8) {
616
- message.routes.push(reader.uint32());
617
-
618
- continue;
619
- }
620
-
621
- if (tag === 10) {
622
- const end2 = reader.uint32() + reader.pos;
623
- while (reader.pos < end2) {
675
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
676
+ if (previousRecursionDepth >= 100) {
677
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
678
+ }
679
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
680
+ try {
681
+ const end = length === undefined ? reader.len : reader.pos + length;
682
+ const message = createBaseStopAdjacency();
683
+ while (reader.pos < end) {
684
+ const tag = reader.uint32();
685
+ switch (tag >>> 3) {
686
+ case 1: {
687
+ if (tag === 8) {
624
688
  message.routes.push(reader.uint32());
689
+
690
+ continue;
625
691
  }
626
692
 
627
- continue;
628
- }
693
+ if (tag === 10) {
694
+ const end2 = reader.uint32() + reader.pos;
695
+ while (reader.pos < end2) {
696
+ message.routes.push(reader.uint32());
697
+ }
698
+
699
+ continue;
700
+ }
629
701
 
630
- break;
631
- }
632
- case 2: {
633
- if (tag !== 18) {
634
702
  break;
635
703
  }
704
+ case 2: {
705
+ if (tag !== 18) {
706
+ break;
707
+ }
636
708
 
637
- message.transfers.push(Transfer.decode(reader, reader.uint32()));
638
- continue;
709
+ message.transfers.push(Transfer.decode(reader, reader.uint32()));
710
+ continue;
711
+ }
639
712
  }
713
+ if ((tag & 7) === 4 || tag === 0) {
714
+ break;
715
+ }
716
+ reader.skip(tag & 7);
640
717
  }
641
- if ((tag & 7) === 4 || tag === 0) {
642
- break;
643
- }
644
- reader.skip(tag & 7);
718
+ return message;
719
+ } finally {
720
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
645
721
  }
646
- return message;
647
722
  },
648
723
 
649
724
  fromJSON(object: any): StopAdjacency {
@@ -689,62 +764,73 @@ export const ServiceRoute: MessageFns<ServiceRoute> = {
689
764
  if (message.name !== "") {
690
765
  writer.uint32(18).string(message.name);
691
766
  }
692
- writer.uint32(26).fork();
693
- for (const v of message.routes) {
694
- writer.uint32(v);
767
+ if (message.routes.length !== 0) {
768
+ writer.uint32(26).fork();
769
+ for (const v of message.routes) {
770
+ writer.uint32(v);
771
+ }
772
+ writer.join();
695
773
  }
696
- writer.join();
697
774
  return writer;
698
775
  },
699
776
 
700
777
  decode(input: BinaryReader | Uint8Array, length?: number): ServiceRoute {
701
778
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
702
- const end = length === undefined ? reader.len : reader.pos + length;
703
- const message = createBaseServiceRoute();
704
- while (reader.pos < end) {
705
- const tag = reader.uint32();
706
- switch (tag >>> 3) {
707
- case 1: {
708
- if (tag !== 8) {
709
- break;
710
- }
779
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
780
+ if (previousRecursionDepth >= 100) {
781
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
782
+ }
783
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
784
+ try {
785
+ const end = length === undefined ? reader.len : reader.pos + length;
786
+ const message = createBaseServiceRoute();
787
+ while (reader.pos < end) {
788
+ const tag = reader.uint32();
789
+ switch (tag >>> 3) {
790
+ case 1: {
791
+ if (tag !== 8) {
792
+ break;
793
+ }
711
794
 
712
- message.type = reader.int32() as any;
713
- continue;
714
- }
715
- case 2: {
716
- if (tag !== 18) {
717
- break;
795
+ message.type = reader.int32() as any;
796
+ continue;
718
797
  }
798
+ case 2: {
799
+ if (tag !== 18) {
800
+ break;
801
+ }
719
802
 
720
- message.name = reader.string();
721
- continue;
722
- }
723
- case 3: {
724
- if (tag === 24) {
725
- message.routes.push(reader.uint32());
726
-
803
+ message.name = reader.string();
727
804
  continue;
728
805
  }
729
-
730
- if (tag === 26) {
731
- const end2 = reader.uint32() + reader.pos;
732
- while (reader.pos < end2) {
806
+ case 3: {
807
+ if (tag === 24) {
733
808
  message.routes.push(reader.uint32());
809
+
810
+ continue;
734
811
  }
735
812
 
736
- continue;
737
- }
813
+ if (tag === 26) {
814
+ const end2 = reader.uint32() + reader.pos;
815
+ while (reader.pos < end2) {
816
+ message.routes.push(reader.uint32());
817
+ }
818
+
819
+ continue;
820
+ }
738
821
 
822
+ break;
823
+ }
824
+ }
825
+ if ((tag & 7) === 4 || tag === 0) {
739
826
  break;
740
827
  }
828
+ reader.skip(tag & 7);
741
829
  }
742
- if ((tag & 7) === 4 || tag === 0) {
743
- break;
744
- }
745
- reader.skip(tag & 7);
830
+ return message;
831
+ } finally {
832
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
746
833
  }
747
- return message;
748
834
  },
749
835
 
750
836
  fromJSON(object: any): ServiceRoute {
@@ -813,76 +899,95 @@ export const Timetable: MessageFns<Timetable> = {
813
899
 
814
900
  decode(input: BinaryReader | Uint8Array, length?: number): Timetable {
815
901
  const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
816
- const end = length === undefined ? reader.len : reader.pos + length;
817
- const message = createBaseTimetable();
818
- while (reader.pos < end) {
819
- const tag = reader.uint32();
820
- switch (tag >>> 3) {
821
- case 1: {
822
- if (tag !== 10) {
823
- break;
824
- }
902
+ const previousRecursionDepth = (reader as any).__tsProtoDecodeDepth ?? 0;
903
+ if (previousRecursionDepth >= 100) {
904
+ throw new globalThis.Error("protobuf decode recursion limit exceeded");
905
+ }
906
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth + 1;
907
+ try {
908
+ const end = length === undefined ? reader.len : reader.pos + length;
909
+ const message = createBaseTimetable();
910
+ while (reader.pos < end) {
911
+ const tag = reader.uint32();
912
+ switch (tag >>> 3) {
913
+ case 1: {
914
+ if (tag !== 10) {
915
+ break;
916
+ }
825
917
 
826
- message.stopsAdjacency.push(StopAdjacency.decode(reader, reader.uint32()));
827
- continue;
828
- }
829
- case 2: {
830
- if (tag !== 18) {
831
- break;
918
+ message.stopsAdjacency.push(StopAdjacency.decode(reader, reader.uint32()));
919
+ continue;
832
920
  }
921
+ case 2: {
922
+ if (tag !== 18) {
923
+ break;
924
+ }
833
925
 
834
- message.routesAdjacency.push(Route.decode(reader, reader.uint32()));
835
- continue;
836
- }
837
- case 3: {
838
- if (tag !== 26) {
839
- break;
926
+ message.routesAdjacency.push(Route.decode(reader, reader.uint32()));
927
+ continue;
840
928
  }
929
+ case 3: {
930
+ if (tag !== 26) {
931
+ break;
932
+ }
841
933
 
842
- message.serviceRoutes.push(ServiceRoute.decode(reader, reader.uint32()));
843
- continue;
844
- }
845
- case 4: {
846
- if (tag !== 34) {
847
- break;
934
+ message.serviceRoutes.push(ServiceRoute.decode(reader, reader.uint32()));
935
+ continue;
848
936
  }
937
+ case 4: {
938
+ if (tag !== 34) {
939
+ break;
940
+ }
849
941
 
850
- message.tripContinuations.push(TripTransferEntry.decode(reader, reader.uint32()));
851
- continue;
852
- }
853
- case 5: {
854
- if (tag !== 42) {
855
- break;
942
+ message.tripContinuations.push(TripTransferEntry.decode(reader, reader.uint32()));
943
+ continue;
856
944
  }
945
+ case 5: {
946
+ if (tag !== 42) {
947
+ break;
948
+ }
857
949
 
858
- message.guaranteedTripTransfers.push(TripTransferEntry.decode(reader, reader.uint32()));
859
- continue;
950
+ message.guaranteedTripTransfers.push(TripTransferEntry.decode(reader, reader.uint32()));
951
+ continue;
952
+ }
860
953
  }
954
+ if ((tag & 7) === 4 || tag === 0) {
955
+ break;
956
+ }
957
+ reader.skip(tag & 7);
861
958
  }
862
- if ((tag & 7) === 4 || tag === 0) {
863
- break;
864
- }
865
- reader.skip(tag & 7);
959
+ return message;
960
+ } finally {
961
+ (reader as any).__tsProtoDecodeDepth = previousRecursionDepth;
866
962
  }
867
- return message;
868
963
  },
869
964
 
870
965
  fromJSON(object: any): Timetable {
871
966
  return {
872
967
  stopsAdjacency: globalThis.Array.isArray(object?.stopsAdjacency)
873
968
  ? object.stopsAdjacency.map((e: any) => StopAdjacency.fromJSON(e))
969
+ : globalThis.Array.isArray(object?.stops_adjacency)
970
+ ? object.stops_adjacency.map((e: any) => StopAdjacency.fromJSON(e))
874
971
  : [],
875
972
  routesAdjacency: globalThis.Array.isArray(object?.routesAdjacency)
876
973
  ? object.routesAdjacency.map((e: any) => Route.fromJSON(e))
974
+ : globalThis.Array.isArray(object?.routes_adjacency)
975
+ ? object.routes_adjacency.map((e: any) => Route.fromJSON(e))
877
976
  : [],
878
977
  serviceRoutes: globalThis.Array.isArray(object?.serviceRoutes)
879
978
  ? object.serviceRoutes.map((e: any) => ServiceRoute.fromJSON(e))
979
+ : globalThis.Array.isArray(object?.service_routes)
980
+ ? object.service_routes.map((e: any) => ServiceRoute.fromJSON(e))
880
981
  : [],
881
982
  tripContinuations: globalThis.Array.isArray(object?.tripContinuations)
882
983
  ? object.tripContinuations.map((e: any) => TripTransferEntry.fromJSON(e))
984
+ : globalThis.Array.isArray(object?.trip_continuations)
985
+ ? object.trip_continuations.map((e: any) => TripTransferEntry.fromJSON(e))
883
986
  : [],
884
987
  guaranteedTripTransfers: globalThis.Array.isArray(object?.guaranteedTripTransfers)
885
988
  ? object.guaranteedTripTransfers.map((e: any) => TripTransferEntry.fromJSON(e))
989
+ : globalThis.Array.isArray(object?.guaranteed_trip_transfers)
990
+ ? object.guaranteed_trip_transfers.map((e: any) => TripTransferEntry.fromJSON(e))
886
991
  : [],
887
992
  };
888
993
  },
@@ -924,7 +1029,7 @@ export const Timetable: MessageFns<Timetable> = {
924
1029
 
925
1030
  function bytesFromBase64(b64: string): Uint8Array {
926
1031
  if ((globalThis as any).Buffer) {
927
- return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
1032
+ return Uint8Array.from((globalThis as any).Buffer.from(b64, "base64"));
928
1033
  } else {
929
1034
  const bin = globalThis.atob(b64);
930
1035
  const arr = new Uint8Array(bin.length);
@@ -937,7 +1042,7 @@ function bytesFromBase64(b64: string): Uint8Array {
937
1042
 
938
1043
  function base64FromBytes(arr: Uint8Array): string {
939
1044
  if ((globalThis as any).Buffer) {
940
- return globalThis.Buffer.from(arr).toString("base64");
1045
+ return (globalThis as any).Buffer.from(arr).toString("base64");
941
1046
  } else {
942
1047
  const bin: string[] = [];
943
1048
  arr.forEach((byte) => {