@replit/protocol 0.5.0 → 0.6.1

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.
@@ -6,45 +6,10 @@ import { WireType } from "@protobuf-ts/runtime";
6
6
  import { UnknownFieldHandler } from "@protobuf-ts/runtime";
7
7
  import { reflectionMergePartial } from "@protobuf-ts/runtime";
8
8
  import { MessageType } from "@protobuf-ts/runtime";
9
- import { Any } from "../../../google/protobuf/any.js";
10
9
  import { ExportMetadata } from "./transfer.js";
11
10
  import { PhaseResponse } from "./transfer.js";
12
11
  import { SignedUrl } from "./transfer.js";
13
12
  import { Duration } from "../../../google/protobuf/duration.js";
14
- /**
15
- * @generated from protobuf enum replit.goval.api.lore.transfer.OrgCallStatus
16
- */
17
- export var OrgCallStatus;
18
- (function (OrgCallStatus) {
19
- /**
20
- * @generated from protobuf enum value: ORG_CALL_STATUS_UNSPECIFIED = 0;
21
- */
22
- OrgCallStatus[OrgCallStatus["UNSPECIFIED"] = 0] = "UNSPECIFIED";
23
- /**
24
- * @generated from protobuf enum value: ORG_CALL_STATUS_SUCCESS = 1;
25
- */
26
- OrgCallStatus[OrgCallStatus["SUCCESS"] = 1] = "SUCCESS";
27
- /**
28
- * @generated from protobuf enum value: ORG_CALL_STATUS_ORG_NOT_FOUND = 2;
29
- */
30
- OrgCallStatus[OrgCallStatus["ORG_NOT_FOUND"] = 2] = "ORG_NOT_FOUND";
31
- /**
32
- * @generated from protobuf enum value: ORG_CALL_STATUS_RETRYABLE_FAILURE = 3;
33
- */
34
- OrgCallStatus[OrgCallStatus["RETRYABLE_FAILURE"] = 3] = "RETRYABLE_FAILURE";
35
- /**
36
- * @generated from protobuf enum value: ORG_CALL_STATUS_NON_RETRYABLE_FAILURE = 4;
37
- */
38
- OrgCallStatus[OrgCallStatus["NON_RETRYABLE_FAILURE"] = 4] = "NON_RETRYABLE_FAILURE";
39
- /**
40
- * The service is still processing this request. The coordinator retries the
41
- * same RPC with exponential backoff until it completes or the phase times
42
- * out.
43
- *
44
- * @generated from protobuf enum value: ORG_CALL_STATUS_IN_PROGRESS = 5;
45
- */
46
- OrgCallStatus[OrgCallStatus["IN_PROGRESS"] = 5] = "IN_PROGRESS";
47
- })(OrgCallStatus || (OrgCallStatus = {}));
48
13
  // @generated message type with reflection information, may provide speed optimized methods
49
14
  class OrgTransferRequest$Type extends MessageType {
50
15
  constructor() {
@@ -444,61 +409,6 @@ class OrgDstAbortDiscardImportRequest$Type extends MessageType {
444
409
  */
445
410
  export const OrgDstAbortDiscardImportRequest = new OrgDstAbortDiscardImportRequest$Type();
446
411
  // @generated message type with reflection information, may provide speed optimized methods
447
- class OrgResponseStatus$Type extends MessageType {
448
- constructor() {
449
- super("replit.goval.api.lore.transfer.OrgResponseStatus", [
450
- { no: 1, name: "code", kind: "enum", T: () => ["replit.goval.api.lore.transfer.OrgCallStatus", OrgCallStatus, "ORG_CALL_STATUS_"] },
451
- { no: 2, name: "description", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
452
- ]);
453
- }
454
- create(value) {
455
- const message = globalThis.Object.create((this.messagePrototype));
456
- message.code = 0;
457
- message.description = "";
458
- if (value !== undefined)
459
- reflectionMergePartial(this, message, value);
460
- return message;
461
- }
462
- internalBinaryRead(reader, length, options, target) {
463
- let message = target ?? this.create(), end = reader.pos + length;
464
- while (reader.pos < end) {
465
- let [fieldNo, wireType] = reader.tag();
466
- switch (fieldNo) {
467
- case /* replit.goval.api.lore.transfer.OrgCallStatus code */ 1:
468
- message.code = reader.int32();
469
- break;
470
- case /* string description */ 2:
471
- message.description = reader.string();
472
- break;
473
- default:
474
- let u = options.readUnknownField;
475
- if (u === "throw")
476
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
477
- let d = reader.skip(wireType);
478
- if (u !== false)
479
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
480
- }
481
- }
482
- return message;
483
- }
484
- internalBinaryWrite(message, writer, options) {
485
- /* replit.goval.api.lore.transfer.OrgCallStatus code = 1; */
486
- if (message.code !== 0)
487
- writer.tag(1, WireType.Varint).int32(message.code);
488
- /* string description = 2; */
489
- if (message.description !== "")
490
- writer.tag(2, WireType.LengthDelimited).string(message.description);
491
- let u = options.writeUnknownFields;
492
- if (u !== false)
493
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
494
- return writer;
495
- }
496
- }
497
- /**
498
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgResponseStatus
499
- */
500
- export const OrgResponseStatus = new OrgResponseStatus$Type();
501
- // @generated message type with reflection information, may provide speed optimized methods
502
412
  class OrgTransferPrincipal$Type extends MessageType {
503
413
  constructor() {
504
414
  super("replit.goval.api.lore.transfer.OrgTransferPrincipal", [
@@ -558,1237 +468,6 @@ class OrgTransferPrincipal$Type extends MessageType {
558
468
  * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgTransferPrincipal
559
469
  */
560
470
  export const OrgTransferPrincipal = new OrgTransferPrincipal$Type();
561
- // @generated message type with reflection information, may provide speed optimized methods
562
- class OrgSourceStopAndDrainRequest$Type extends MessageType {
563
- constructor() {
564
- super("replit.goval.api.lore.transfer.OrgSourceStopAndDrainRequest", [
565
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
566
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
567
- { no: 3, name: "ttl", kind: "message", T: () => Duration },
568
- { no: 4, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
569
- ]);
570
- }
571
- create(value) {
572
- const message = globalThis.Object.create((this.messagePrototype));
573
- message.orgId = "";
574
- message.transferId = "";
575
- if (value !== undefined)
576
- reflectionMergePartial(this, message, value);
577
- return message;
578
- }
579
- internalBinaryRead(reader, length, options, target) {
580
- let message = target ?? this.create(), end = reader.pos + length;
581
- while (reader.pos < end) {
582
- let [fieldNo, wireType] = reader.tag();
583
- switch (fieldNo) {
584
- case /* string org_id */ 1:
585
- message.orgId = reader.string();
586
- break;
587
- case /* string transfer_id */ 2:
588
- message.transferId = reader.string();
589
- break;
590
- case /* google.protobuf.Duration ttl */ 3:
591
- message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
592
- break;
593
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 4:
594
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
595
- break;
596
- default:
597
- let u = options.readUnknownField;
598
- if (u === "throw")
599
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
600
- let d = reader.skip(wireType);
601
- if (u !== false)
602
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
603
- }
604
- }
605
- return message;
606
- }
607
- internalBinaryWrite(message, writer, options) {
608
- /* string org_id = 1; */
609
- if (message.orgId !== "")
610
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
611
- /* string transfer_id = 2; */
612
- if (message.transferId !== "")
613
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
614
- /* google.protobuf.Duration ttl = 3; */
615
- if (message.ttl)
616
- Duration.internalBinaryWrite(message.ttl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
617
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 4; */
618
- if (message.principal)
619
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
620
- let u = options.writeUnknownFields;
621
- if (u !== false)
622
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
623
- return writer;
624
- }
625
- }
626
- /**
627
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceStopAndDrainRequest
628
- */
629
- export const OrgSourceStopAndDrainRequest = new OrgSourceStopAndDrainRequest$Type();
630
- // @generated message type with reflection information, may provide speed optimized methods
631
- class OrgSourceStopAndDrainResponse$Type extends MessageType {
632
- constructor() {
633
- super("replit.goval.api.lore.transfer.OrgSourceStopAndDrainResponse", [
634
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
635
- ]);
636
- }
637
- create(value) {
638
- const message = globalThis.Object.create((this.messagePrototype));
639
- if (value !== undefined)
640
- reflectionMergePartial(this, message, value);
641
- return message;
642
- }
643
- internalBinaryRead(reader, length, options, target) {
644
- let message = target ?? this.create(), end = reader.pos + length;
645
- while (reader.pos < end) {
646
- let [fieldNo, wireType] = reader.tag();
647
- switch (fieldNo) {
648
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
649
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
650
- break;
651
- default:
652
- let u = options.readUnknownField;
653
- if (u === "throw")
654
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
655
- let d = reader.skip(wireType);
656
- if (u !== false)
657
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
658
- }
659
- }
660
- return message;
661
- }
662
- internalBinaryWrite(message, writer, options) {
663
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
664
- if (message.status)
665
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
666
- let u = options.writeUnknownFields;
667
- if (u !== false)
668
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
669
- return writer;
670
- }
671
- }
672
- /**
673
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceStopAndDrainResponse
674
- */
675
- export const OrgSourceStopAndDrainResponse = new OrgSourceStopAndDrainResponse$Type();
676
- // @generated message type with reflection information, may provide speed optimized methods
677
- class OrgIsSourceFullyDrainedRequest$Type extends MessageType {
678
- constructor() {
679
- super("replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedRequest", [
680
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
681
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
682
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
683
- ]);
684
- }
685
- create(value) {
686
- const message = globalThis.Object.create((this.messagePrototype));
687
- message.orgId = "";
688
- message.transferId = "";
689
- if (value !== undefined)
690
- reflectionMergePartial(this, message, value);
691
- return message;
692
- }
693
- internalBinaryRead(reader, length, options, target) {
694
- let message = target ?? this.create(), end = reader.pos + length;
695
- while (reader.pos < end) {
696
- let [fieldNo, wireType] = reader.tag();
697
- switch (fieldNo) {
698
- case /* string org_id */ 1:
699
- message.orgId = reader.string();
700
- break;
701
- case /* string transfer_id */ 2:
702
- message.transferId = reader.string();
703
- break;
704
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
705
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
706
- break;
707
- default:
708
- let u = options.readUnknownField;
709
- if (u === "throw")
710
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
711
- let d = reader.skip(wireType);
712
- if (u !== false)
713
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
714
- }
715
- }
716
- return message;
717
- }
718
- internalBinaryWrite(message, writer, options) {
719
- /* string org_id = 1; */
720
- if (message.orgId !== "")
721
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
722
- /* string transfer_id = 2; */
723
- if (message.transferId !== "")
724
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
725
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
726
- if (message.principal)
727
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
728
- let u = options.writeUnknownFields;
729
- if (u !== false)
730
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
731
- return writer;
732
- }
733
- }
734
- /**
735
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedRequest
736
- */
737
- export const OrgIsSourceFullyDrainedRequest = new OrgIsSourceFullyDrainedRequest$Type();
738
- // @generated message type with reflection information, may provide speed optimized methods
739
- class OrgIsSourceFullyDrainedResponse$Type extends MessageType {
740
- constructor() {
741
- super("replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedResponse", [
742
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus },
743
- { no: 2, name: "fully_drained", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
744
- ]);
745
- }
746
- create(value) {
747
- const message = globalThis.Object.create((this.messagePrototype));
748
- message.fullyDrained = false;
749
- if (value !== undefined)
750
- reflectionMergePartial(this, message, value);
751
- return message;
752
- }
753
- internalBinaryRead(reader, length, options, target) {
754
- let message = target ?? this.create(), end = reader.pos + length;
755
- while (reader.pos < end) {
756
- let [fieldNo, wireType] = reader.tag();
757
- switch (fieldNo) {
758
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
759
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
760
- break;
761
- case /* bool fully_drained */ 2:
762
- message.fullyDrained = reader.bool();
763
- break;
764
- default:
765
- let u = options.readUnknownField;
766
- if (u === "throw")
767
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
768
- let d = reader.skip(wireType);
769
- if (u !== false)
770
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
771
- }
772
- }
773
- return message;
774
- }
775
- internalBinaryWrite(message, writer, options) {
776
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
777
- if (message.status)
778
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
779
- /* bool fully_drained = 2; */
780
- if (message.fullyDrained !== false)
781
- writer.tag(2, WireType.Varint).bool(message.fullyDrained);
782
- let u = options.writeUnknownFields;
783
- if (u !== false)
784
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
785
- return writer;
786
- }
787
- }
788
- /**
789
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedResponse
790
- */
791
- export const OrgIsSourceFullyDrainedResponse = new OrgIsSourceFullyDrainedResponse$Type();
792
- // @generated message type with reflection information, may provide speed optimized methods
793
- class OrgSourceRemoveTombstoneRequest$Type extends MessageType {
794
- constructor() {
795
- super("replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneRequest", [
796
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
797
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
798
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
799
- ]);
800
- }
801
- create(value) {
802
- const message = globalThis.Object.create((this.messagePrototype));
803
- message.orgId = "";
804
- message.transferId = "";
805
- if (value !== undefined)
806
- reflectionMergePartial(this, message, value);
807
- return message;
808
- }
809
- internalBinaryRead(reader, length, options, target) {
810
- let message = target ?? this.create(), end = reader.pos + length;
811
- while (reader.pos < end) {
812
- let [fieldNo, wireType] = reader.tag();
813
- switch (fieldNo) {
814
- case /* string org_id */ 1:
815
- message.orgId = reader.string();
816
- break;
817
- case /* string transfer_id */ 2:
818
- message.transferId = reader.string();
819
- break;
820
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
821
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
822
- break;
823
- default:
824
- let u = options.readUnknownField;
825
- if (u === "throw")
826
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
827
- let d = reader.skip(wireType);
828
- if (u !== false)
829
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
830
- }
831
- }
832
- return message;
833
- }
834
- internalBinaryWrite(message, writer, options) {
835
- /* string org_id = 1; */
836
- if (message.orgId !== "")
837
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
838
- /* string transfer_id = 2; */
839
- if (message.transferId !== "")
840
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
841
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
842
- if (message.principal)
843
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
844
- let u = options.writeUnknownFields;
845
- if (u !== false)
846
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
847
- return writer;
848
- }
849
- }
850
- /**
851
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneRequest
852
- */
853
- export const OrgSourceRemoveTombstoneRequest = new OrgSourceRemoveTombstoneRequest$Type();
854
- // @generated message type with reflection information, may provide speed optimized methods
855
- class OrgSourceRemoveTombstoneResponse$Type extends MessageType {
856
- constructor() {
857
- super("replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneResponse", [
858
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
859
- ]);
860
- }
861
- create(value) {
862
- const message = globalThis.Object.create((this.messagePrototype));
863
- if (value !== undefined)
864
- reflectionMergePartial(this, message, value);
865
- return message;
866
- }
867
- internalBinaryRead(reader, length, options, target) {
868
- let message = target ?? this.create(), end = reader.pos + length;
869
- while (reader.pos < end) {
870
- let [fieldNo, wireType] = reader.tag();
871
- switch (fieldNo) {
872
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
873
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
874
- break;
875
- default:
876
- let u = options.readUnknownField;
877
- if (u === "throw")
878
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
879
- let d = reader.skip(wireType);
880
- if (u !== false)
881
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
882
- }
883
- }
884
- return message;
885
- }
886
- internalBinaryWrite(message, writer, options) {
887
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
888
- if (message.status)
889
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
890
- let u = options.writeUnknownFields;
891
- if (u !== false)
892
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
893
- return writer;
894
- }
895
- }
896
- /**
897
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneResponse
898
- */
899
- export const OrgSourceRemoveTombstoneResponse = new OrgSourceRemoveTombstoneResponse$Type();
900
- // @generated message type with reflection information, may provide speed optimized methods
901
- class OrgSourceTransferOutRequest$Type extends MessageType {
902
- constructor() {
903
- super("replit.goval.api.lore.transfer.OrgSourceTransferOutRequest", [
904
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
905
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
906
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
907
- ]);
908
- }
909
- create(value) {
910
- const message = globalThis.Object.create((this.messagePrototype));
911
- message.orgId = "";
912
- message.transferId = "";
913
- if (value !== undefined)
914
- reflectionMergePartial(this, message, value);
915
- return message;
916
- }
917
- internalBinaryRead(reader, length, options, target) {
918
- let message = target ?? this.create(), end = reader.pos + length;
919
- while (reader.pos < end) {
920
- let [fieldNo, wireType] = reader.tag();
921
- switch (fieldNo) {
922
- case /* string org_id */ 1:
923
- message.orgId = reader.string();
924
- break;
925
- case /* string transfer_id */ 2:
926
- message.transferId = reader.string();
927
- break;
928
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
929
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
930
- break;
931
- default:
932
- let u = options.readUnknownField;
933
- if (u === "throw")
934
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
935
- let d = reader.skip(wireType);
936
- if (u !== false)
937
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
938
- }
939
- }
940
- return message;
941
- }
942
- internalBinaryWrite(message, writer, options) {
943
- /* string org_id = 1; */
944
- if (message.orgId !== "")
945
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
946
- /* string transfer_id = 2; */
947
- if (message.transferId !== "")
948
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
949
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
950
- if (message.principal)
951
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
952
- let u = options.writeUnknownFields;
953
- if (u !== false)
954
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
955
- return writer;
956
- }
957
- }
958
- /**
959
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceTransferOutRequest
960
- */
961
- export const OrgSourceTransferOutRequest = new OrgSourceTransferOutRequest$Type();
962
- // @generated message type with reflection information, may provide speed optimized methods
963
- class OrgSourceTransferOutResponse$Type extends MessageType {
964
- constructor() {
965
- super("replit.goval.api.lore.transfer.OrgSourceTransferOutResponse", [
966
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus },
967
- { no: 2, name: "payload", kind: "message", T: () => Any }
968
- ]);
969
- }
970
- create(value) {
971
- const message = globalThis.Object.create((this.messagePrototype));
972
- if (value !== undefined)
973
- reflectionMergePartial(this, message, value);
974
- return message;
975
- }
976
- internalBinaryRead(reader, length, options, target) {
977
- let message = target ?? this.create(), end = reader.pos + length;
978
- while (reader.pos < end) {
979
- let [fieldNo, wireType] = reader.tag();
980
- switch (fieldNo) {
981
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
982
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
983
- break;
984
- case /* google.protobuf.Any payload */ 2:
985
- message.payload = Any.internalBinaryRead(reader, reader.uint32(), options, message.payload);
986
- break;
987
- default:
988
- let u = options.readUnknownField;
989
- if (u === "throw")
990
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
991
- let d = reader.skip(wireType);
992
- if (u !== false)
993
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
994
- }
995
- }
996
- return message;
997
- }
998
- internalBinaryWrite(message, writer, options) {
999
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1000
- if (message.status)
1001
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1002
- /* google.protobuf.Any payload = 2; */
1003
- if (message.payload)
1004
- Any.internalBinaryWrite(message.payload, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
1005
- let u = options.writeUnknownFields;
1006
- if (u !== false)
1007
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1008
- return writer;
1009
- }
1010
- }
1011
- /**
1012
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceTransferOutResponse
1013
- */
1014
- export const OrgSourceTransferOutResponse = new OrgSourceTransferOutResponse$Type();
1015
- // @generated message type with reflection information, may provide speed optimized methods
1016
- class OrgDestinationTransferInRequest$Type extends MessageType {
1017
- constructor() {
1018
- super("replit.goval.api.lore.transfer.OrgDestinationTransferInRequest", [
1019
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1020
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1021
- { no: 3, name: "payload", kind: "message", T: () => Any },
1022
- { no: 4, name: "ttl", kind: "message", T: () => Duration },
1023
- { no: 5, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1024
- ]);
1025
- }
1026
- create(value) {
1027
- const message = globalThis.Object.create((this.messagePrototype));
1028
- message.orgId = "";
1029
- message.transferId = "";
1030
- if (value !== undefined)
1031
- reflectionMergePartial(this, message, value);
1032
- return message;
1033
- }
1034
- internalBinaryRead(reader, length, options, target) {
1035
- let message = target ?? this.create(), end = reader.pos + length;
1036
- while (reader.pos < end) {
1037
- let [fieldNo, wireType] = reader.tag();
1038
- switch (fieldNo) {
1039
- case /* string org_id */ 1:
1040
- message.orgId = reader.string();
1041
- break;
1042
- case /* string transfer_id */ 2:
1043
- message.transferId = reader.string();
1044
- break;
1045
- case /* google.protobuf.Any payload */ 3:
1046
- message.payload = Any.internalBinaryRead(reader, reader.uint32(), options, message.payload);
1047
- break;
1048
- case /* google.protobuf.Duration ttl */ 4:
1049
- message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
1050
- break;
1051
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 5:
1052
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1053
- break;
1054
- default:
1055
- let u = options.readUnknownField;
1056
- if (u === "throw")
1057
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1058
- let d = reader.skip(wireType);
1059
- if (u !== false)
1060
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1061
- }
1062
- }
1063
- return message;
1064
- }
1065
- internalBinaryWrite(message, writer, options) {
1066
- /* string org_id = 1; */
1067
- if (message.orgId !== "")
1068
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
1069
- /* string transfer_id = 2; */
1070
- if (message.transferId !== "")
1071
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1072
- /* google.protobuf.Any payload = 3; */
1073
- if (message.payload)
1074
- Any.internalBinaryWrite(message.payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1075
- /* google.protobuf.Duration ttl = 4; */
1076
- if (message.ttl)
1077
- Duration.internalBinaryWrite(message.ttl, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
1078
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 5; */
1079
- if (message.principal)
1080
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
1081
- let u = options.writeUnknownFields;
1082
- if (u !== false)
1083
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1084
- return writer;
1085
- }
1086
- }
1087
- /**
1088
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationTransferInRequest
1089
- */
1090
- export const OrgDestinationTransferInRequest = new OrgDestinationTransferInRequest$Type();
1091
- // @generated message type with reflection information, may provide speed optimized methods
1092
- class OrgDestinationTransferInResponse$Type extends MessageType {
1093
- constructor() {
1094
- super("replit.goval.api.lore.transfer.OrgDestinationTransferInResponse", [
1095
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1096
- ]);
1097
- }
1098
- create(value) {
1099
- const message = globalThis.Object.create((this.messagePrototype));
1100
- if (value !== undefined)
1101
- reflectionMergePartial(this, message, value);
1102
- return message;
1103
- }
1104
- internalBinaryRead(reader, length, options, target) {
1105
- let message = target ?? this.create(), end = reader.pos + length;
1106
- while (reader.pos < end) {
1107
- let [fieldNo, wireType] = reader.tag();
1108
- switch (fieldNo) {
1109
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1110
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1111
- break;
1112
- default:
1113
- let u = options.readUnknownField;
1114
- if (u === "throw")
1115
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1116
- let d = reader.skip(wireType);
1117
- if (u !== false)
1118
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1119
- }
1120
- }
1121
- return message;
1122
- }
1123
- internalBinaryWrite(message, writer, options) {
1124
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1125
- if (message.status)
1126
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1127
- let u = options.writeUnknownFields;
1128
- if (u !== false)
1129
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1130
- return writer;
1131
- }
1132
- }
1133
- /**
1134
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationTransferInResponse
1135
- */
1136
- export const OrgDestinationTransferInResponse = new OrgDestinationTransferInResponse$Type();
1137
- // @generated message type with reflection information, may provide speed optimized methods
1138
- class OrgDestinationAddTombstoneRequest$Type extends MessageType {
1139
- constructor() {
1140
- super("replit.goval.api.lore.transfer.OrgDestinationAddTombstoneRequest", [
1141
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1142
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1143
- { no: 3, name: "ttl", kind: "message", T: () => Duration },
1144
- { no: 4, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1145
- ]);
1146
- }
1147
- create(value) {
1148
- const message = globalThis.Object.create((this.messagePrototype));
1149
- message.orgId = "";
1150
- message.transferId = "";
1151
- if (value !== undefined)
1152
- reflectionMergePartial(this, message, value);
1153
- return message;
1154
- }
1155
- internalBinaryRead(reader, length, options, target) {
1156
- let message = target ?? this.create(), end = reader.pos + length;
1157
- while (reader.pos < end) {
1158
- let [fieldNo, wireType] = reader.tag();
1159
- switch (fieldNo) {
1160
- case /* string org_id */ 1:
1161
- message.orgId = reader.string();
1162
- break;
1163
- case /* string transfer_id */ 2:
1164
- message.transferId = reader.string();
1165
- break;
1166
- case /* google.protobuf.Duration ttl */ 3:
1167
- message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
1168
- break;
1169
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 4:
1170
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1171
- break;
1172
- default:
1173
- let u = options.readUnknownField;
1174
- if (u === "throw")
1175
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1176
- let d = reader.skip(wireType);
1177
- if (u !== false)
1178
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1179
- }
1180
- }
1181
- return message;
1182
- }
1183
- internalBinaryWrite(message, writer, options) {
1184
- /* string org_id = 1; */
1185
- if (message.orgId !== "")
1186
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
1187
- /* string transfer_id = 2; */
1188
- if (message.transferId !== "")
1189
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1190
- /* google.protobuf.Duration ttl = 3; */
1191
- if (message.ttl)
1192
- Duration.internalBinaryWrite(message.ttl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1193
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 4; */
1194
- if (message.principal)
1195
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
1196
- let u = options.writeUnknownFields;
1197
- if (u !== false)
1198
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1199
- return writer;
1200
- }
1201
- }
1202
- /**
1203
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAddTombstoneRequest
1204
- */
1205
- export const OrgDestinationAddTombstoneRequest = new OrgDestinationAddTombstoneRequest$Type();
1206
- // @generated message type with reflection information, may provide speed optimized methods
1207
- class OrgDestinationAddTombstoneResponse$Type extends MessageType {
1208
- constructor() {
1209
- super("replit.goval.api.lore.transfer.OrgDestinationAddTombstoneResponse", [
1210
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1211
- ]);
1212
- }
1213
- create(value) {
1214
- const message = globalThis.Object.create((this.messagePrototype));
1215
- if (value !== undefined)
1216
- reflectionMergePartial(this, message, value);
1217
- return message;
1218
- }
1219
- internalBinaryRead(reader, length, options, target) {
1220
- let message = target ?? this.create(), end = reader.pos + length;
1221
- while (reader.pos < end) {
1222
- let [fieldNo, wireType] = reader.tag();
1223
- switch (fieldNo) {
1224
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1225
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1226
- break;
1227
- default:
1228
- let u = options.readUnknownField;
1229
- if (u === "throw")
1230
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1231
- let d = reader.skip(wireType);
1232
- if (u !== false)
1233
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1234
- }
1235
- }
1236
- return message;
1237
- }
1238
- internalBinaryWrite(message, writer, options) {
1239
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1240
- if (message.status)
1241
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1242
- let u = options.writeUnknownFields;
1243
- if (u !== false)
1244
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1245
- return writer;
1246
- }
1247
- }
1248
- /**
1249
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAddTombstoneResponse
1250
- */
1251
- export const OrgDestinationAddTombstoneResponse = new OrgDestinationAddTombstoneResponse$Type();
1252
- // @generated message type with reflection information, may provide speed optimized methods
1253
- class OrgDestinationRemoveTombstoneRequest$Type extends MessageType {
1254
- constructor() {
1255
- super("replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneRequest", [
1256
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1257
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1258
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1259
- ]);
1260
- }
1261
- create(value) {
1262
- const message = globalThis.Object.create((this.messagePrototype));
1263
- message.orgId = "";
1264
- message.transferId = "";
1265
- if (value !== undefined)
1266
- reflectionMergePartial(this, message, value);
1267
- return message;
1268
- }
1269
- internalBinaryRead(reader, length, options, target) {
1270
- let message = target ?? this.create(), end = reader.pos + length;
1271
- while (reader.pos < end) {
1272
- let [fieldNo, wireType] = reader.tag();
1273
- switch (fieldNo) {
1274
- case /* string org_id */ 1:
1275
- message.orgId = reader.string();
1276
- break;
1277
- case /* string transfer_id */ 2:
1278
- message.transferId = reader.string();
1279
- break;
1280
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
1281
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1282
- break;
1283
- default:
1284
- let u = options.readUnknownField;
1285
- if (u === "throw")
1286
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1287
- let d = reader.skip(wireType);
1288
- if (u !== false)
1289
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1290
- }
1291
- }
1292
- return message;
1293
- }
1294
- internalBinaryWrite(message, writer, options) {
1295
- /* string org_id = 1; */
1296
- if (message.orgId !== "")
1297
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
1298
- /* string transfer_id = 2; */
1299
- if (message.transferId !== "")
1300
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1301
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
1302
- if (message.principal)
1303
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1304
- let u = options.writeUnknownFields;
1305
- if (u !== false)
1306
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1307
- return writer;
1308
- }
1309
- }
1310
- /**
1311
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneRequest
1312
- */
1313
- export const OrgDestinationRemoveTombstoneRequest = new OrgDestinationRemoveTombstoneRequest$Type();
1314
- // @generated message type with reflection information, may provide speed optimized methods
1315
- class OrgDestinationRemoveTombstoneResponse$Type extends MessageType {
1316
- constructor() {
1317
- super("replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneResponse", [
1318
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1319
- ]);
1320
- }
1321
- create(value) {
1322
- const message = globalThis.Object.create((this.messagePrototype));
1323
- if (value !== undefined)
1324
- reflectionMergePartial(this, message, value);
1325
- return message;
1326
- }
1327
- internalBinaryRead(reader, length, options, target) {
1328
- let message = target ?? this.create(), end = reader.pos + length;
1329
- while (reader.pos < end) {
1330
- let [fieldNo, wireType] = reader.tag();
1331
- switch (fieldNo) {
1332
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1333
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1334
- break;
1335
- default:
1336
- let u = options.readUnknownField;
1337
- if (u === "throw")
1338
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1339
- let d = reader.skip(wireType);
1340
- if (u !== false)
1341
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1342
- }
1343
- }
1344
- return message;
1345
- }
1346
- internalBinaryWrite(message, writer, options) {
1347
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1348
- if (message.status)
1349
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1350
- let u = options.writeUnknownFields;
1351
- if (u !== false)
1352
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1353
- return writer;
1354
- }
1355
- }
1356
- /**
1357
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneResponse
1358
- */
1359
- export const OrgDestinationRemoveTombstoneResponse = new OrgDestinationRemoveTombstoneResponse$Type();
1360
- // @generated message type with reflection information, may provide speed optimized methods
1361
- class OrgSourceAbortRequest$Type extends MessageType {
1362
- constructor() {
1363
- super("replit.goval.api.lore.transfer.OrgSourceAbortRequest", [
1364
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1365
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1366
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1367
- ]);
1368
- }
1369
- create(value) {
1370
- const message = globalThis.Object.create((this.messagePrototype));
1371
- message.orgId = "";
1372
- message.transferId = "";
1373
- if (value !== undefined)
1374
- reflectionMergePartial(this, message, value);
1375
- return message;
1376
- }
1377
- internalBinaryRead(reader, length, options, target) {
1378
- let message = target ?? this.create(), end = reader.pos + length;
1379
- while (reader.pos < end) {
1380
- let [fieldNo, wireType] = reader.tag();
1381
- switch (fieldNo) {
1382
- case /* string org_id */ 1:
1383
- message.orgId = reader.string();
1384
- break;
1385
- case /* string transfer_id */ 2:
1386
- message.transferId = reader.string();
1387
- break;
1388
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
1389
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1390
- break;
1391
- default:
1392
- let u = options.readUnknownField;
1393
- if (u === "throw")
1394
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1395
- let d = reader.skip(wireType);
1396
- if (u !== false)
1397
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1398
- }
1399
- }
1400
- return message;
1401
- }
1402
- internalBinaryWrite(message, writer, options) {
1403
- /* string org_id = 1; */
1404
- if (message.orgId !== "")
1405
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
1406
- /* string transfer_id = 2; */
1407
- if (message.transferId !== "")
1408
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1409
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
1410
- if (message.principal)
1411
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1412
- let u = options.writeUnknownFields;
1413
- if (u !== false)
1414
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1415
- return writer;
1416
- }
1417
- }
1418
- /**
1419
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceAbortRequest
1420
- */
1421
- export const OrgSourceAbortRequest = new OrgSourceAbortRequest$Type();
1422
- // @generated message type with reflection information, may provide speed optimized methods
1423
- class OrgSourceAbortResponse$Type extends MessageType {
1424
- constructor() {
1425
- super("replit.goval.api.lore.transfer.OrgSourceAbortResponse", [
1426
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1427
- ]);
1428
- }
1429
- create(value) {
1430
- const message = globalThis.Object.create((this.messagePrototype));
1431
- if (value !== undefined)
1432
- reflectionMergePartial(this, message, value);
1433
- return message;
1434
- }
1435
- internalBinaryRead(reader, length, options, target) {
1436
- let message = target ?? this.create(), end = reader.pos + length;
1437
- while (reader.pos < end) {
1438
- let [fieldNo, wireType] = reader.tag();
1439
- switch (fieldNo) {
1440
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1441
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1442
- break;
1443
- default:
1444
- let u = options.readUnknownField;
1445
- if (u === "throw")
1446
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1447
- let d = reader.skip(wireType);
1448
- if (u !== false)
1449
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1450
- }
1451
- }
1452
- return message;
1453
- }
1454
- internalBinaryWrite(message, writer, options) {
1455
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1456
- if (message.status)
1457
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1458
- let u = options.writeUnknownFields;
1459
- if (u !== false)
1460
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1461
- return writer;
1462
- }
1463
- }
1464
- /**
1465
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceAbortResponse
1466
- */
1467
- export const OrgSourceAbortResponse = new OrgSourceAbortResponse$Type();
1468
- // @generated message type with reflection information, may provide speed optimized methods
1469
- class OrgDestinationAbortRequest$Type extends MessageType {
1470
- constructor() {
1471
- super("replit.goval.api.lore.transfer.OrgDestinationAbortRequest", [
1472
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1473
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1474
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1475
- ]);
1476
- }
1477
- create(value) {
1478
- const message = globalThis.Object.create((this.messagePrototype));
1479
- message.orgId = "";
1480
- message.transferId = "";
1481
- if (value !== undefined)
1482
- reflectionMergePartial(this, message, value);
1483
- return message;
1484
- }
1485
- internalBinaryRead(reader, length, options, target) {
1486
- let message = target ?? this.create(), end = reader.pos + length;
1487
- while (reader.pos < end) {
1488
- let [fieldNo, wireType] = reader.tag();
1489
- switch (fieldNo) {
1490
- case /* string org_id */ 1:
1491
- message.orgId = reader.string();
1492
- break;
1493
- case /* string transfer_id */ 2:
1494
- message.transferId = reader.string();
1495
- break;
1496
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
1497
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1498
- break;
1499
- default:
1500
- let u = options.readUnknownField;
1501
- if (u === "throw")
1502
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1503
- let d = reader.skip(wireType);
1504
- if (u !== false)
1505
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1506
- }
1507
- }
1508
- return message;
1509
- }
1510
- internalBinaryWrite(message, writer, options) {
1511
- /* string org_id = 1; */
1512
- if (message.orgId !== "")
1513
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
1514
- /* string transfer_id = 2; */
1515
- if (message.transferId !== "")
1516
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1517
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
1518
- if (message.principal)
1519
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1520
- let u = options.writeUnknownFields;
1521
- if (u !== false)
1522
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1523
- return writer;
1524
- }
1525
- }
1526
- /**
1527
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAbortRequest
1528
- */
1529
- export const OrgDestinationAbortRequest = new OrgDestinationAbortRequest$Type();
1530
- // @generated message type with reflection information, may provide speed optimized methods
1531
- class OrgDestinationAbortResponse$Type extends MessageType {
1532
- constructor() {
1533
- super("replit.goval.api.lore.transfer.OrgDestinationAbortResponse", [
1534
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1535
- ]);
1536
- }
1537
- create(value) {
1538
- const message = globalThis.Object.create((this.messagePrototype));
1539
- if (value !== undefined)
1540
- reflectionMergePartial(this, message, value);
1541
- return message;
1542
- }
1543
- internalBinaryRead(reader, length, options, target) {
1544
- let message = target ?? this.create(), end = reader.pos + length;
1545
- while (reader.pos < end) {
1546
- let [fieldNo, wireType] = reader.tag();
1547
- switch (fieldNo) {
1548
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1549
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1550
- break;
1551
- default:
1552
- let u = options.readUnknownField;
1553
- if (u === "throw")
1554
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1555
- let d = reader.skip(wireType);
1556
- if (u !== false)
1557
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1558
- }
1559
- }
1560
- return message;
1561
- }
1562
- internalBinaryWrite(message, writer, options) {
1563
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1564
- if (message.status)
1565
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1566
- let u = options.writeUnknownFields;
1567
- if (u !== false)
1568
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1569
- return writer;
1570
- }
1571
- }
1572
- /**
1573
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAbortResponse
1574
- */
1575
- export const OrgDestinationAbortResponse = new OrgDestinationAbortResponse$Type();
1576
- // @generated message type with reflection information, may provide speed optimized methods
1577
- class OrgSourceCleanUpTransferDataRequest$Type extends MessageType {
1578
- constructor() {
1579
- super("replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataRequest", [
1580
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1581
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1582
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1583
- ]);
1584
- }
1585
- create(value) {
1586
- const message = globalThis.Object.create((this.messagePrototype));
1587
- message.orgId = "";
1588
- message.transferId = "";
1589
- if (value !== undefined)
1590
- reflectionMergePartial(this, message, value);
1591
- return message;
1592
- }
1593
- internalBinaryRead(reader, length, options, target) {
1594
- let message = target ?? this.create(), end = reader.pos + length;
1595
- while (reader.pos < end) {
1596
- let [fieldNo, wireType] = reader.tag();
1597
- switch (fieldNo) {
1598
- case /* string org_id */ 1:
1599
- message.orgId = reader.string();
1600
- break;
1601
- case /* string transfer_id */ 2:
1602
- message.transferId = reader.string();
1603
- break;
1604
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
1605
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1606
- break;
1607
- default:
1608
- let u = options.readUnknownField;
1609
- if (u === "throw")
1610
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1611
- let d = reader.skip(wireType);
1612
- if (u !== false)
1613
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1614
- }
1615
- }
1616
- return message;
1617
- }
1618
- internalBinaryWrite(message, writer, options) {
1619
- /* string org_id = 1; */
1620
- if (message.orgId !== "")
1621
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
1622
- /* string transfer_id = 2; */
1623
- if (message.transferId !== "")
1624
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1625
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
1626
- if (message.principal)
1627
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1628
- let u = options.writeUnknownFields;
1629
- if (u !== false)
1630
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1631
- return writer;
1632
- }
1633
- }
1634
- /**
1635
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataRequest
1636
- */
1637
- export const OrgSourceCleanUpTransferDataRequest = new OrgSourceCleanUpTransferDataRequest$Type();
1638
- // @generated message type with reflection information, may provide speed optimized methods
1639
- class OrgSourceCleanUpTransferDataResponse$Type extends MessageType {
1640
- constructor() {
1641
- super("replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataResponse", [
1642
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1643
- ]);
1644
- }
1645
- create(value) {
1646
- const message = globalThis.Object.create((this.messagePrototype));
1647
- if (value !== undefined)
1648
- reflectionMergePartial(this, message, value);
1649
- return message;
1650
- }
1651
- internalBinaryRead(reader, length, options, target) {
1652
- let message = target ?? this.create(), end = reader.pos + length;
1653
- while (reader.pos < end) {
1654
- let [fieldNo, wireType] = reader.tag();
1655
- switch (fieldNo) {
1656
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1657
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1658
- break;
1659
- default:
1660
- let u = options.readUnknownField;
1661
- if (u === "throw")
1662
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1663
- let d = reader.skip(wireType);
1664
- if (u !== false)
1665
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1666
- }
1667
- }
1668
- return message;
1669
- }
1670
- internalBinaryWrite(message, writer, options) {
1671
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1672
- if (message.status)
1673
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1674
- let u = options.writeUnknownFields;
1675
- if (u !== false)
1676
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1677
- return writer;
1678
- }
1679
- }
1680
- /**
1681
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataResponse
1682
- */
1683
- export const OrgSourceCleanUpTransferDataResponse = new OrgSourceCleanUpTransferDataResponse$Type();
1684
- // @generated message type with reflection information, may provide speed optimized methods
1685
- class OrgSourceDeleteRequest$Type extends MessageType {
1686
- constructor() {
1687
- super("replit.goval.api.lore.transfer.OrgSourceDeleteRequest", [
1688
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1689
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1690
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1691
- ]);
1692
- }
1693
- create(value) {
1694
- const message = globalThis.Object.create((this.messagePrototype));
1695
- message.orgId = "";
1696
- message.transferId = "";
1697
- if (value !== undefined)
1698
- reflectionMergePartial(this, message, value);
1699
- return message;
1700
- }
1701
- internalBinaryRead(reader, length, options, target) {
1702
- let message = target ?? this.create(), end = reader.pos + length;
1703
- while (reader.pos < end) {
1704
- let [fieldNo, wireType] = reader.tag();
1705
- switch (fieldNo) {
1706
- case /* string org_id */ 1:
1707
- message.orgId = reader.string();
1708
- break;
1709
- case /* string transfer_id */ 2:
1710
- message.transferId = reader.string();
1711
- break;
1712
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
1713
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1714
- break;
1715
- default:
1716
- let u = options.readUnknownField;
1717
- if (u === "throw")
1718
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1719
- let d = reader.skip(wireType);
1720
- if (u !== false)
1721
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1722
- }
1723
- }
1724
- return message;
1725
- }
1726
- internalBinaryWrite(message, writer, options) {
1727
- /* string org_id = 1; */
1728
- if (message.orgId !== "")
1729
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
1730
- /* string transfer_id = 2; */
1731
- if (message.transferId !== "")
1732
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1733
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
1734
- if (message.principal)
1735
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1736
- let u = options.writeUnknownFields;
1737
- if (u !== false)
1738
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1739
- return writer;
1740
- }
1741
- }
1742
- /**
1743
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceDeleteRequest
1744
- */
1745
- export const OrgSourceDeleteRequest = new OrgSourceDeleteRequest$Type();
1746
- // @generated message type with reflection information, may provide speed optimized methods
1747
- class OrgSourceDeleteResponse$Type extends MessageType {
1748
- constructor() {
1749
- super("replit.goval.api.lore.transfer.OrgSourceDeleteResponse", [
1750
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1751
- ]);
1752
- }
1753
- create(value) {
1754
- const message = globalThis.Object.create((this.messagePrototype));
1755
- if (value !== undefined)
1756
- reflectionMergePartial(this, message, value);
1757
- return message;
1758
- }
1759
- internalBinaryRead(reader, length, options, target) {
1760
- let message = target ?? this.create(), end = reader.pos + length;
1761
- while (reader.pos < end) {
1762
- let [fieldNo, wireType] = reader.tag();
1763
- switch (fieldNo) {
1764
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1765
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1766
- break;
1767
- default:
1768
- let u = options.readUnknownField;
1769
- if (u === "throw")
1770
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1771
- let d = reader.skip(wireType);
1772
- if (u !== false)
1773
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1774
- }
1775
- }
1776
- return message;
1777
- }
1778
- internalBinaryWrite(message, writer, options) {
1779
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1780
- if (message.status)
1781
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
1782
- let u = options.writeUnknownFields;
1783
- if (u !== false)
1784
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1785
- return writer;
1786
- }
1787
- }
1788
- /**
1789
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceDeleteResponse
1790
- */
1791
- export const OrgSourceDeleteResponse = new OrgSourceDeleteResponse$Type();
1792
471
  /**
1793
472
  * @generated ServiceType for protobuf service replit.goval.api.lore.transfer.TransferOrgHomeCell
1794
473
  */
@@ -1800,16 +479,5 @@ export const TransferOrgHomeCell = new ServiceType("replit.goval.api.lore.transf
1800
479
  { name: "SrcResume", options: {}, I: OrgTransferRequest, O: PhaseResponse },
1801
480
  { name: "DstAbortDiscardImport", options: {}, I: OrgDstAbortDiscardImportRequest, O: PhaseResponse },
1802
481
  { name: "DstActivate", options: {}, I: OrgTransferRequest, O: PhaseResponse },
1803
- { name: "SrcDelete", options: {}, I: OrgTransferRequest, O: PhaseResponse },
1804
- { name: "SourceStopAndDrain", options: {}, I: OrgSourceStopAndDrainRequest, O: OrgSourceStopAndDrainResponse },
1805
- { name: "IsSourceFullyDrained", options: {}, I: OrgIsSourceFullyDrainedRequest, O: OrgIsSourceFullyDrainedResponse },
1806
- { name: "SourceRemoveTombstone", options: {}, I: OrgSourceRemoveTombstoneRequest, O: OrgSourceRemoveTombstoneResponse },
1807
- { name: "SourceTransferOut", options: {}, I: OrgSourceTransferOutRequest, O: OrgSourceTransferOutResponse },
1808
- { name: "DestinationTransferIn", options: {}, I: OrgDestinationTransferInRequest, O: OrgDestinationTransferInResponse },
1809
- { name: "DestinationAddTombstone", options: {}, I: OrgDestinationAddTombstoneRequest, O: OrgDestinationAddTombstoneResponse },
1810
- { name: "DestinationRemoveTombstone", options: {}, I: OrgDestinationRemoveTombstoneRequest, O: OrgDestinationRemoveTombstoneResponse },
1811
- { name: "SourceAbort", options: {}, I: OrgSourceAbortRequest, O: OrgSourceAbortResponse },
1812
- { name: "DestinationAbort", options: {}, I: OrgDestinationAbortRequest, O: OrgDestinationAbortResponse },
1813
- { name: "SourceCleanUpTransferData", options: {}, I: OrgSourceCleanUpTransferDataRequest, O: OrgSourceCleanUpTransferDataResponse },
1814
- { name: "SourceDelete", options: {}, I: OrgSourceDeleteRequest, O: OrgSourceDeleteResponse }
482
+ { name: "SrcDelete", options: {}, I: OrgTransferRequest, O: PhaseResponse }
1815
483
  ]);