@replit/protocol 0.4.32 → 0.6.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.
@@ -6,844 +6,14 @@ 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";
9
+ import { ExportMetadata } from "./transfer.js";
10
+ import { PhaseResponse } from "./transfer.js";
11
+ import { SignedUrl } from "./transfer.js";
10
12
  import { Duration } from "../../../google/protobuf/duration.js";
11
- /**
12
- * @generated from protobuf enum replit.goval.api.lore.transfer.OrgCallStatus
13
- */
14
- export var OrgCallStatus;
15
- (function (OrgCallStatus) {
16
- /**
17
- * @generated from protobuf enum value: ORG_CALL_STATUS_UNSPECIFIED = 0;
18
- */
19
- OrgCallStatus[OrgCallStatus["UNSPECIFIED"] = 0] = "UNSPECIFIED";
20
- /**
21
- * @generated from protobuf enum value: ORG_CALL_STATUS_SUCCESS = 1;
22
- */
23
- OrgCallStatus[OrgCallStatus["SUCCESS"] = 1] = "SUCCESS";
24
- /**
25
- * @generated from protobuf enum value: ORG_CALL_STATUS_ORG_NOT_FOUND = 2;
26
- */
27
- OrgCallStatus[OrgCallStatus["ORG_NOT_FOUND"] = 2] = "ORG_NOT_FOUND";
28
- /**
29
- * @generated from protobuf enum value: ORG_CALL_STATUS_RETRYABLE_FAILURE = 3;
30
- */
31
- OrgCallStatus[OrgCallStatus["RETRYABLE_FAILURE"] = 3] = "RETRYABLE_FAILURE";
32
- /**
33
- * @generated from protobuf enum value: ORG_CALL_STATUS_NON_RETRYABLE_FAILURE = 4;
34
- */
35
- OrgCallStatus[OrgCallStatus["NON_RETRYABLE_FAILURE"] = 4] = "NON_RETRYABLE_FAILURE";
36
- })(OrgCallStatus || (OrgCallStatus = {}));
37
- // @generated message type with reflection information, may provide speed optimized methods
38
- class OrgResponseStatus$Type extends MessageType {
39
- constructor() {
40
- super("replit.goval.api.lore.transfer.OrgResponseStatus", [
41
- { no: 1, name: "code", kind: "enum", T: () => ["replit.goval.api.lore.transfer.OrgCallStatus", OrgCallStatus, "ORG_CALL_STATUS_"] },
42
- { no: 2, name: "description", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
43
- ]);
44
- }
45
- create(value) {
46
- const message = globalThis.Object.create((this.messagePrototype));
47
- message.code = 0;
48
- message.description = "";
49
- if (value !== undefined)
50
- reflectionMergePartial(this, message, value);
51
- return message;
52
- }
53
- internalBinaryRead(reader, length, options, target) {
54
- let message = target ?? this.create(), end = reader.pos + length;
55
- while (reader.pos < end) {
56
- let [fieldNo, wireType] = reader.tag();
57
- switch (fieldNo) {
58
- case /* replit.goval.api.lore.transfer.OrgCallStatus code */ 1:
59
- message.code = reader.int32();
60
- break;
61
- case /* string description */ 2:
62
- message.description = reader.string();
63
- break;
64
- default:
65
- let u = options.readUnknownField;
66
- if (u === "throw")
67
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
68
- let d = reader.skip(wireType);
69
- if (u !== false)
70
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
71
- }
72
- }
73
- return message;
74
- }
75
- internalBinaryWrite(message, writer, options) {
76
- /* replit.goval.api.lore.transfer.OrgCallStatus code = 1; */
77
- if (message.code !== 0)
78
- writer.tag(1, WireType.Varint).int32(message.code);
79
- /* string description = 2; */
80
- if (message.description !== "")
81
- writer.tag(2, WireType.LengthDelimited).string(message.description);
82
- let u = options.writeUnknownFields;
83
- if (u !== false)
84
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
85
- return writer;
86
- }
87
- }
88
- /**
89
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgResponseStatus
90
- */
91
- export const OrgResponseStatus = new OrgResponseStatus$Type();
92
- // @generated message type with reflection information, may provide speed optimized methods
93
- class OrgTransferPrincipal$Type extends MessageType {
94
- constructor() {
95
- super("replit.goval.api.lore.transfer.OrgTransferPrincipal", [
96
- { no: 1, name: "user_id", kind: "scalar", oneof: "principal", T: 13 /*ScalarType.UINT32*/ },
97
- { no: 2, name: "service_id", kind: "scalar", oneof: "principal", T: 9 /*ScalarType.STRING*/ }
98
- ]);
99
- }
100
- create(value) {
101
- const message = globalThis.Object.create((this.messagePrototype));
102
- message.principal = { oneofKind: undefined };
103
- if (value !== undefined)
104
- reflectionMergePartial(this, message, value);
105
- return message;
106
- }
107
- internalBinaryRead(reader, length, options, target) {
108
- let message = target ?? this.create(), end = reader.pos + length;
109
- while (reader.pos < end) {
110
- let [fieldNo, wireType] = reader.tag();
111
- switch (fieldNo) {
112
- case /* uint32 user_id */ 1:
113
- message.principal = {
114
- oneofKind: "userId",
115
- userId: reader.uint32()
116
- };
117
- break;
118
- case /* string service_id */ 2:
119
- message.principal = {
120
- oneofKind: "serviceId",
121
- serviceId: reader.string()
122
- };
123
- break;
124
- default:
125
- let u = options.readUnknownField;
126
- if (u === "throw")
127
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
128
- let d = reader.skip(wireType);
129
- if (u !== false)
130
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
131
- }
132
- }
133
- return message;
134
- }
135
- internalBinaryWrite(message, writer, options) {
136
- /* uint32 user_id = 1; */
137
- if (message.principal.oneofKind === "userId")
138
- writer.tag(1, WireType.Varint).uint32(message.principal.userId);
139
- /* string service_id = 2; */
140
- if (message.principal.oneofKind === "serviceId")
141
- writer.tag(2, WireType.LengthDelimited).string(message.principal.serviceId);
142
- let u = options.writeUnknownFields;
143
- if (u !== false)
144
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
145
- return writer;
146
- }
147
- }
148
- /**
149
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgTransferPrincipal
150
- */
151
- export const OrgTransferPrincipal = new OrgTransferPrincipal$Type();
152
- // @generated message type with reflection information, may provide speed optimized methods
153
- class OrgSourceStopAndDrainRequest$Type extends MessageType {
154
- constructor() {
155
- super("replit.goval.api.lore.transfer.OrgSourceStopAndDrainRequest", [
156
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
157
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
158
- { no: 3, name: "ttl", kind: "message", T: () => Duration },
159
- { no: 4, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
160
- ]);
161
- }
162
- create(value) {
163
- const message = globalThis.Object.create((this.messagePrototype));
164
- message.orgId = "";
165
- message.transferId = "";
166
- if (value !== undefined)
167
- reflectionMergePartial(this, message, value);
168
- return message;
169
- }
170
- internalBinaryRead(reader, length, options, target) {
171
- let message = target ?? this.create(), end = reader.pos + length;
172
- while (reader.pos < end) {
173
- let [fieldNo, wireType] = reader.tag();
174
- switch (fieldNo) {
175
- case /* string org_id */ 1:
176
- message.orgId = reader.string();
177
- break;
178
- case /* string transfer_id */ 2:
179
- message.transferId = reader.string();
180
- break;
181
- case /* google.protobuf.Duration ttl */ 3:
182
- message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
183
- break;
184
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 4:
185
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
186
- break;
187
- default:
188
- let u = options.readUnknownField;
189
- if (u === "throw")
190
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
191
- let d = reader.skip(wireType);
192
- if (u !== false)
193
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
194
- }
195
- }
196
- return message;
197
- }
198
- internalBinaryWrite(message, writer, options) {
199
- /* string org_id = 1; */
200
- if (message.orgId !== "")
201
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
202
- /* string transfer_id = 2; */
203
- if (message.transferId !== "")
204
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
205
- /* google.protobuf.Duration ttl = 3; */
206
- if (message.ttl)
207
- Duration.internalBinaryWrite(message.ttl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
208
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 4; */
209
- if (message.principal)
210
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
211
- let u = options.writeUnknownFields;
212
- if (u !== false)
213
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
214
- return writer;
215
- }
216
- }
217
- /**
218
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceStopAndDrainRequest
219
- */
220
- export const OrgSourceStopAndDrainRequest = new OrgSourceStopAndDrainRequest$Type();
221
- // @generated message type with reflection information, may provide speed optimized methods
222
- class OrgSourceStopAndDrainResponse$Type extends MessageType {
223
- constructor() {
224
- super("replit.goval.api.lore.transfer.OrgSourceStopAndDrainResponse", [
225
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
226
- ]);
227
- }
228
- create(value) {
229
- const message = globalThis.Object.create((this.messagePrototype));
230
- if (value !== undefined)
231
- reflectionMergePartial(this, message, value);
232
- return message;
233
- }
234
- internalBinaryRead(reader, length, options, target) {
235
- let message = target ?? this.create(), end = reader.pos + length;
236
- while (reader.pos < end) {
237
- let [fieldNo, wireType] = reader.tag();
238
- switch (fieldNo) {
239
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
240
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
241
- break;
242
- default:
243
- let u = options.readUnknownField;
244
- if (u === "throw")
245
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
246
- let d = reader.skip(wireType);
247
- if (u !== false)
248
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
249
- }
250
- }
251
- return message;
252
- }
253
- internalBinaryWrite(message, writer, options) {
254
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
255
- if (message.status)
256
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
257
- let u = options.writeUnknownFields;
258
- if (u !== false)
259
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
260
- return writer;
261
- }
262
- }
263
- /**
264
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceStopAndDrainResponse
265
- */
266
- export const OrgSourceStopAndDrainResponse = new OrgSourceStopAndDrainResponse$Type();
267
- // @generated message type with reflection information, may provide speed optimized methods
268
- class OrgIsSourceFullyDrainedRequest$Type extends MessageType {
269
- constructor() {
270
- super("replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedRequest", [
271
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
272
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
273
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
274
- ]);
275
- }
276
- create(value) {
277
- const message = globalThis.Object.create((this.messagePrototype));
278
- message.orgId = "";
279
- message.transferId = "";
280
- if (value !== undefined)
281
- reflectionMergePartial(this, message, value);
282
- return message;
283
- }
284
- internalBinaryRead(reader, length, options, target) {
285
- let message = target ?? this.create(), end = reader.pos + length;
286
- while (reader.pos < end) {
287
- let [fieldNo, wireType] = reader.tag();
288
- switch (fieldNo) {
289
- case /* string org_id */ 1:
290
- message.orgId = reader.string();
291
- break;
292
- case /* string transfer_id */ 2:
293
- message.transferId = reader.string();
294
- break;
295
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
296
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
297
- break;
298
- default:
299
- let u = options.readUnknownField;
300
- if (u === "throw")
301
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
302
- let d = reader.skip(wireType);
303
- if (u !== false)
304
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
305
- }
306
- }
307
- return message;
308
- }
309
- internalBinaryWrite(message, writer, options) {
310
- /* string org_id = 1; */
311
- if (message.orgId !== "")
312
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
313
- /* string transfer_id = 2; */
314
- if (message.transferId !== "")
315
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
316
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
317
- if (message.principal)
318
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
319
- let u = options.writeUnknownFields;
320
- if (u !== false)
321
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
322
- return writer;
323
- }
324
- }
325
- /**
326
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedRequest
327
- */
328
- export const OrgIsSourceFullyDrainedRequest = new OrgIsSourceFullyDrainedRequest$Type();
329
- // @generated message type with reflection information, may provide speed optimized methods
330
- class OrgIsSourceFullyDrainedResponse$Type extends MessageType {
331
- constructor() {
332
- super("replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedResponse", [
333
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus },
334
- { no: 2, name: "fully_drained", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
335
- ]);
336
- }
337
- create(value) {
338
- const message = globalThis.Object.create((this.messagePrototype));
339
- message.fullyDrained = false;
340
- if (value !== undefined)
341
- reflectionMergePartial(this, message, value);
342
- return message;
343
- }
344
- internalBinaryRead(reader, length, options, target) {
345
- let message = target ?? this.create(), end = reader.pos + length;
346
- while (reader.pos < end) {
347
- let [fieldNo, wireType] = reader.tag();
348
- switch (fieldNo) {
349
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
350
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
351
- break;
352
- case /* bool fully_drained */ 2:
353
- message.fullyDrained = reader.bool();
354
- break;
355
- default:
356
- let u = options.readUnknownField;
357
- if (u === "throw")
358
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
359
- let d = reader.skip(wireType);
360
- if (u !== false)
361
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
362
- }
363
- }
364
- return message;
365
- }
366
- internalBinaryWrite(message, writer, options) {
367
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
368
- if (message.status)
369
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
370
- /* bool fully_drained = 2; */
371
- if (message.fullyDrained !== false)
372
- writer.tag(2, WireType.Varint).bool(message.fullyDrained);
373
- let u = options.writeUnknownFields;
374
- if (u !== false)
375
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
376
- return writer;
377
- }
378
- }
379
- /**
380
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgIsSourceFullyDrainedResponse
381
- */
382
- export const OrgIsSourceFullyDrainedResponse = new OrgIsSourceFullyDrainedResponse$Type();
383
- // @generated message type with reflection information, may provide speed optimized methods
384
- class OrgSourceRemoveTombstoneRequest$Type extends MessageType {
385
- constructor() {
386
- super("replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneRequest", [
387
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
388
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
389
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
390
- ]);
391
- }
392
- create(value) {
393
- const message = globalThis.Object.create((this.messagePrototype));
394
- message.orgId = "";
395
- message.transferId = "";
396
- if (value !== undefined)
397
- reflectionMergePartial(this, message, value);
398
- return message;
399
- }
400
- internalBinaryRead(reader, length, options, target) {
401
- let message = target ?? this.create(), end = reader.pos + length;
402
- while (reader.pos < end) {
403
- let [fieldNo, wireType] = reader.tag();
404
- switch (fieldNo) {
405
- case /* string org_id */ 1:
406
- message.orgId = reader.string();
407
- break;
408
- case /* string transfer_id */ 2:
409
- message.transferId = reader.string();
410
- break;
411
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
412
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
413
- break;
414
- default:
415
- let u = options.readUnknownField;
416
- if (u === "throw")
417
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
418
- let d = reader.skip(wireType);
419
- if (u !== false)
420
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
421
- }
422
- }
423
- return message;
424
- }
425
- internalBinaryWrite(message, writer, options) {
426
- /* string org_id = 1; */
427
- if (message.orgId !== "")
428
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
429
- /* string transfer_id = 2; */
430
- if (message.transferId !== "")
431
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
432
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
433
- if (message.principal)
434
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
435
- let u = options.writeUnknownFields;
436
- if (u !== false)
437
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
438
- return writer;
439
- }
440
- }
441
- /**
442
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneRequest
443
- */
444
- export const OrgSourceRemoveTombstoneRequest = new OrgSourceRemoveTombstoneRequest$Type();
445
- // @generated message type with reflection information, may provide speed optimized methods
446
- class OrgSourceRemoveTombstoneResponse$Type extends MessageType {
447
- constructor() {
448
- super("replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneResponse", [
449
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
450
- ]);
451
- }
452
- create(value) {
453
- const message = globalThis.Object.create((this.messagePrototype));
454
- if (value !== undefined)
455
- reflectionMergePartial(this, message, value);
456
- return message;
457
- }
458
- internalBinaryRead(reader, length, options, target) {
459
- let message = target ?? this.create(), end = reader.pos + length;
460
- while (reader.pos < end) {
461
- let [fieldNo, wireType] = reader.tag();
462
- switch (fieldNo) {
463
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
464
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
465
- break;
466
- default:
467
- let u = options.readUnknownField;
468
- if (u === "throw")
469
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
470
- let d = reader.skip(wireType);
471
- if (u !== false)
472
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
473
- }
474
- }
475
- return message;
476
- }
477
- internalBinaryWrite(message, writer, options) {
478
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
479
- if (message.status)
480
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
481
- let u = options.writeUnknownFields;
482
- if (u !== false)
483
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
484
- return writer;
485
- }
486
- }
487
- /**
488
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceRemoveTombstoneResponse
489
- */
490
- export const OrgSourceRemoveTombstoneResponse = new OrgSourceRemoveTombstoneResponse$Type();
491
- // @generated message type with reflection information, may provide speed optimized methods
492
- class OrgSourceTransferOutRequest$Type extends MessageType {
493
- constructor() {
494
- super("replit.goval.api.lore.transfer.OrgSourceTransferOutRequest", [
495
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
496
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
497
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
498
- ]);
499
- }
500
- create(value) {
501
- const message = globalThis.Object.create((this.messagePrototype));
502
- message.orgId = "";
503
- message.transferId = "";
504
- if (value !== undefined)
505
- reflectionMergePartial(this, message, value);
506
- return message;
507
- }
508
- internalBinaryRead(reader, length, options, target) {
509
- let message = target ?? this.create(), end = reader.pos + length;
510
- while (reader.pos < end) {
511
- let [fieldNo, wireType] = reader.tag();
512
- switch (fieldNo) {
513
- case /* string org_id */ 1:
514
- message.orgId = reader.string();
515
- break;
516
- case /* string transfer_id */ 2:
517
- message.transferId = reader.string();
518
- break;
519
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
520
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
521
- break;
522
- default:
523
- let u = options.readUnknownField;
524
- if (u === "throw")
525
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
526
- let d = reader.skip(wireType);
527
- if (u !== false)
528
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
529
- }
530
- }
531
- return message;
532
- }
533
- internalBinaryWrite(message, writer, options) {
534
- /* string org_id = 1; */
535
- if (message.orgId !== "")
536
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
537
- /* string transfer_id = 2; */
538
- if (message.transferId !== "")
539
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
540
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
541
- if (message.principal)
542
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
543
- let u = options.writeUnknownFields;
544
- if (u !== false)
545
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
546
- return writer;
547
- }
548
- }
549
- /**
550
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceTransferOutRequest
551
- */
552
- export const OrgSourceTransferOutRequest = new OrgSourceTransferOutRequest$Type();
553
- // @generated message type with reflection information, may provide speed optimized methods
554
- class OrgSourceTransferOutResponse$Type extends MessageType {
555
- constructor() {
556
- super("replit.goval.api.lore.transfer.OrgSourceTransferOutResponse", [
557
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus },
558
- { no: 2, name: "payload", kind: "message", T: () => Any }
559
- ]);
560
- }
561
- create(value) {
562
- const message = globalThis.Object.create((this.messagePrototype));
563
- if (value !== undefined)
564
- reflectionMergePartial(this, message, value);
565
- return message;
566
- }
567
- internalBinaryRead(reader, length, options, target) {
568
- let message = target ?? this.create(), end = reader.pos + length;
569
- while (reader.pos < end) {
570
- let [fieldNo, wireType] = reader.tag();
571
- switch (fieldNo) {
572
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
573
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
574
- break;
575
- case /* google.protobuf.Any payload */ 2:
576
- message.payload = Any.internalBinaryRead(reader, reader.uint32(), options, message.payload);
577
- break;
578
- default:
579
- let u = options.readUnknownField;
580
- if (u === "throw")
581
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
582
- let d = reader.skip(wireType);
583
- if (u !== false)
584
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
585
- }
586
- }
587
- return message;
588
- }
589
- internalBinaryWrite(message, writer, options) {
590
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
591
- if (message.status)
592
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
593
- /* google.protobuf.Any payload = 2; */
594
- if (message.payload)
595
- Any.internalBinaryWrite(message.payload, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
596
- let u = options.writeUnknownFields;
597
- if (u !== false)
598
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
599
- return writer;
600
- }
601
- }
602
- /**
603
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceTransferOutResponse
604
- */
605
- export const OrgSourceTransferOutResponse = new OrgSourceTransferOutResponse$Type();
606
- // @generated message type with reflection information, may provide speed optimized methods
607
- class OrgDestinationTransferInRequest$Type extends MessageType {
608
- constructor() {
609
- super("replit.goval.api.lore.transfer.OrgDestinationTransferInRequest", [
610
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
611
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
612
- { no: 3, name: "payload", kind: "message", T: () => Any },
613
- { no: 4, name: "ttl", kind: "message", T: () => Duration },
614
- { no: 5, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
615
- ]);
616
- }
617
- create(value) {
618
- const message = globalThis.Object.create((this.messagePrototype));
619
- message.orgId = "";
620
- message.transferId = "";
621
- if (value !== undefined)
622
- reflectionMergePartial(this, message, value);
623
- return message;
624
- }
625
- internalBinaryRead(reader, length, options, target) {
626
- let message = target ?? this.create(), end = reader.pos + length;
627
- while (reader.pos < end) {
628
- let [fieldNo, wireType] = reader.tag();
629
- switch (fieldNo) {
630
- case /* string org_id */ 1:
631
- message.orgId = reader.string();
632
- break;
633
- case /* string transfer_id */ 2:
634
- message.transferId = reader.string();
635
- break;
636
- case /* google.protobuf.Any payload */ 3:
637
- message.payload = Any.internalBinaryRead(reader, reader.uint32(), options, message.payload);
638
- break;
639
- case /* google.protobuf.Duration ttl */ 4:
640
- message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
641
- break;
642
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 5:
643
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
644
- break;
645
- default:
646
- let u = options.readUnknownField;
647
- if (u === "throw")
648
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
649
- let d = reader.skip(wireType);
650
- if (u !== false)
651
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
652
- }
653
- }
654
- return message;
655
- }
656
- internalBinaryWrite(message, writer, options) {
657
- /* string org_id = 1; */
658
- if (message.orgId !== "")
659
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
660
- /* string transfer_id = 2; */
661
- if (message.transferId !== "")
662
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
663
- /* google.protobuf.Any payload = 3; */
664
- if (message.payload)
665
- Any.internalBinaryWrite(message.payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
666
- /* google.protobuf.Duration ttl = 4; */
667
- if (message.ttl)
668
- Duration.internalBinaryWrite(message.ttl, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
669
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 5; */
670
- if (message.principal)
671
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
672
- let u = options.writeUnknownFields;
673
- if (u !== false)
674
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
675
- return writer;
676
- }
677
- }
678
- /**
679
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationTransferInRequest
680
- */
681
- export const OrgDestinationTransferInRequest = new OrgDestinationTransferInRequest$Type();
682
- // @generated message type with reflection information, may provide speed optimized methods
683
- class OrgDestinationTransferInResponse$Type extends MessageType {
684
- constructor() {
685
- super("replit.goval.api.lore.transfer.OrgDestinationTransferInResponse", [
686
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
687
- ]);
688
- }
689
- create(value) {
690
- const message = globalThis.Object.create((this.messagePrototype));
691
- if (value !== undefined)
692
- reflectionMergePartial(this, message, value);
693
- return message;
694
- }
695
- internalBinaryRead(reader, length, options, target) {
696
- let message = target ?? this.create(), end = reader.pos + length;
697
- while (reader.pos < end) {
698
- let [fieldNo, wireType] = reader.tag();
699
- switch (fieldNo) {
700
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
701
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
702
- break;
703
- default:
704
- let u = options.readUnknownField;
705
- if (u === "throw")
706
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
707
- let d = reader.skip(wireType);
708
- if (u !== false)
709
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
710
- }
711
- }
712
- return message;
713
- }
714
- internalBinaryWrite(message, writer, options) {
715
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
716
- if (message.status)
717
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
718
- let u = options.writeUnknownFields;
719
- if (u !== false)
720
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
721
- return writer;
722
- }
723
- }
724
- /**
725
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationTransferInResponse
726
- */
727
- export const OrgDestinationTransferInResponse = new OrgDestinationTransferInResponse$Type();
728
- // @generated message type with reflection information, may provide speed optimized methods
729
- class OrgDestinationAddTombstoneRequest$Type extends MessageType {
730
- constructor() {
731
- super("replit.goval.api.lore.transfer.OrgDestinationAddTombstoneRequest", [
732
- { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
733
- { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
734
- { no: 3, name: "ttl", kind: "message", T: () => Duration },
735
- { no: 4, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
736
- ]);
737
- }
738
- create(value) {
739
- const message = globalThis.Object.create((this.messagePrototype));
740
- message.orgId = "";
741
- message.transferId = "";
742
- if (value !== undefined)
743
- reflectionMergePartial(this, message, value);
744
- return message;
745
- }
746
- internalBinaryRead(reader, length, options, target) {
747
- let message = target ?? this.create(), end = reader.pos + length;
748
- while (reader.pos < end) {
749
- let [fieldNo, wireType] = reader.tag();
750
- switch (fieldNo) {
751
- case /* string org_id */ 1:
752
- message.orgId = reader.string();
753
- break;
754
- case /* string transfer_id */ 2:
755
- message.transferId = reader.string();
756
- break;
757
- case /* google.protobuf.Duration ttl */ 3:
758
- message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
759
- break;
760
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 4:
761
- message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
762
- break;
763
- default:
764
- let u = options.readUnknownField;
765
- if (u === "throw")
766
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
767
- let d = reader.skip(wireType);
768
- if (u !== false)
769
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
770
- }
771
- }
772
- return message;
773
- }
774
- internalBinaryWrite(message, writer, options) {
775
- /* string org_id = 1; */
776
- if (message.orgId !== "")
777
- writer.tag(1, WireType.LengthDelimited).string(message.orgId);
778
- /* string transfer_id = 2; */
779
- if (message.transferId !== "")
780
- writer.tag(2, WireType.LengthDelimited).string(message.transferId);
781
- /* google.protobuf.Duration ttl = 3; */
782
- if (message.ttl)
783
- Duration.internalBinaryWrite(message.ttl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
784
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 4; */
785
- if (message.principal)
786
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
787
- let u = options.writeUnknownFields;
788
- if (u !== false)
789
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
790
- return writer;
791
- }
792
- }
793
- /**
794
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAddTombstoneRequest
795
- */
796
- export const OrgDestinationAddTombstoneRequest = new OrgDestinationAddTombstoneRequest$Type();
797
- // @generated message type with reflection information, may provide speed optimized methods
798
- class OrgDestinationAddTombstoneResponse$Type extends MessageType {
799
- constructor() {
800
- super("replit.goval.api.lore.transfer.OrgDestinationAddTombstoneResponse", [
801
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
802
- ]);
803
- }
804
- create(value) {
805
- const message = globalThis.Object.create((this.messagePrototype));
806
- if (value !== undefined)
807
- reflectionMergePartial(this, message, value);
808
- return message;
809
- }
810
- internalBinaryRead(reader, length, options, target) {
811
- let message = target ?? this.create(), end = reader.pos + length;
812
- while (reader.pos < end) {
813
- let [fieldNo, wireType] = reader.tag();
814
- switch (fieldNo) {
815
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
816
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
817
- break;
818
- default:
819
- let u = options.readUnknownField;
820
- if (u === "throw")
821
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
822
- let d = reader.skip(wireType);
823
- if (u !== false)
824
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
825
- }
826
- }
827
- return message;
828
- }
829
- internalBinaryWrite(message, writer, options) {
830
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
831
- if (message.status)
832
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
833
- let u = options.writeUnknownFields;
834
- if (u !== false)
835
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
836
- return writer;
837
- }
838
- }
839
- /**
840
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAddTombstoneResponse
841
- */
842
- export const OrgDestinationAddTombstoneResponse = new OrgDestinationAddTombstoneResponse$Type();
843
13
  // @generated message type with reflection information, may provide speed optimized methods
844
- class OrgDestinationRemoveTombstoneRequest$Type extends MessageType {
14
+ class OrgTransferRequest$Type extends MessageType {
845
15
  constructor() {
846
- super("replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneRequest", [
16
+ super("replit.goval.api.lore.transfer.OrgTransferRequest", [
847
17
  { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
848
18
  { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
849
19
  { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
@@ -899,62 +69,17 @@ class OrgDestinationRemoveTombstoneRequest$Type extends MessageType {
899
69
  }
900
70
  }
901
71
  /**
902
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneRequest
903
- */
904
- export const OrgDestinationRemoveTombstoneRequest = new OrgDestinationRemoveTombstoneRequest$Type();
905
- // @generated message type with reflection information, may provide speed optimized methods
906
- class OrgDestinationRemoveTombstoneResponse$Type extends MessageType {
907
- constructor() {
908
- super("replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneResponse", [
909
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
910
- ]);
911
- }
912
- create(value) {
913
- const message = globalThis.Object.create((this.messagePrototype));
914
- if (value !== undefined)
915
- reflectionMergePartial(this, message, value);
916
- return message;
917
- }
918
- internalBinaryRead(reader, length, options, target) {
919
- let message = target ?? this.create(), end = reader.pos + length;
920
- while (reader.pos < end) {
921
- let [fieldNo, wireType] = reader.tag();
922
- switch (fieldNo) {
923
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
924
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
925
- break;
926
- default:
927
- let u = options.readUnknownField;
928
- if (u === "throw")
929
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
930
- let d = reader.skip(wireType);
931
- if (u !== false)
932
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
933
- }
934
- }
935
- return message;
936
- }
937
- internalBinaryWrite(message, writer, options) {
938
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
939
- if (message.status)
940
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
941
- let u = options.writeUnknownFields;
942
- if (u !== false)
943
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
944
- return writer;
945
- }
946
- }
947
- /**
948
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationRemoveTombstoneResponse
72
+ * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgTransferRequest
949
73
  */
950
- export const OrgDestinationRemoveTombstoneResponse = new OrgDestinationRemoveTombstoneResponse$Type();
74
+ export const OrgTransferRequest = new OrgTransferRequest$Type();
951
75
  // @generated message type with reflection information, may provide speed optimized methods
952
- class OrgSourceAbortRequest$Type extends MessageType {
76
+ class OrgSrcStopAndDrainRequest$Type extends MessageType {
953
77
  constructor() {
954
- super("replit.goval.api.lore.transfer.OrgSourceAbortRequest", [
78
+ super("replit.goval.api.lore.transfer.OrgSrcStopAndDrainRequest", [
955
79
  { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
956
80
  { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
957
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
81
+ { no: 3, name: "ttl", kind: "message", T: () => Duration },
82
+ { no: 4, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
958
83
  ]);
959
84
  }
960
85
  create(value) {
@@ -976,7 +101,10 @@ class OrgSourceAbortRequest$Type extends MessageType {
976
101
  case /* string transfer_id */ 2:
977
102
  message.transferId = reader.string();
978
103
  break;
979
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
104
+ case /* google.protobuf.Duration ttl */ 3:
105
+ message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
106
+ break;
107
+ case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 4:
980
108
  message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
981
109
  break;
982
110
  default:
@@ -997,55 +125,12 @@ class OrgSourceAbortRequest$Type extends MessageType {
997
125
  /* string transfer_id = 2; */
998
126
  if (message.transferId !== "")
999
127
  writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1000
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
128
+ /* google.protobuf.Duration ttl = 3; */
129
+ if (message.ttl)
130
+ Duration.internalBinaryWrite(message.ttl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
131
+ /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 4; */
1001
132
  if (message.principal)
1002
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1003
- let u = options.writeUnknownFields;
1004
- if (u !== false)
1005
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1006
- return writer;
1007
- }
1008
- }
1009
- /**
1010
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceAbortRequest
1011
- */
1012
- export const OrgSourceAbortRequest = new OrgSourceAbortRequest$Type();
1013
- // @generated message type with reflection information, may provide speed optimized methods
1014
- class OrgSourceAbortResponse$Type extends MessageType {
1015
- constructor() {
1016
- super("replit.goval.api.lore.transfer.OrgSourceAbortResponse", [
1017
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1018
- ]);
1019
- }
1020
- create(value) {
1021
- const message = globalThis.Object.create((this.messagePrototype));
1022
- if (value !== undefined)
1023
- reflectionMergePartial(this, message, value);
1024
- return message;
1025
- }
1026
- internalBinaryRead(reader, length, options, target) {
1027
- let message = target ?? this.create(), end = reader.pos + length;
1028
- while (reader.pos < end) {
1029
- let [fieldNo, wireType] = reader.tag();
1030
- switch (fieldNo) {
1031
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1032
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1033
- break;
1034
- default:
1035
- let u = options.readUnknownField;
1036
- if (u === "throw")
1037
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1038
- let d = reader.skip(wireType);
1039
- if (u !== false)
1040
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1041
- }
1042
- }
1043
- return message;
1044
- }
1045
- internalBinaryWrite(message, writer, options) {
1046
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1047
- if (message.status)
1048
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
133
+ OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
1049
134
  let u = options.writeUnknownFields;
1050
135
  if (u !== false)
1051
136
  (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1053,16 +138,17 @@ class OrgSourceAbortResponse$Type extends MessageType {
1053
138
  }
1054
139
  }
1055
140
  /**
1056
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceAbortResponse
141
+ * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSrcStopAndDrainRequest
1057
142
  */
1058
- export const OrgSourceAbortResponse = new OrgSourceAbortResponse$Type();
143
+ export const OrgSrcStopAndDrainRequest = new OrgSrcStopAndDrainRequest$Type();
1059
144
  // @generated message type with reflection information, may provide speed optimized methods
1060
- class OrgDestinationAbortRequest$Type extends MessageType {
145
+ class OrgSrcTransferOutRequest$Type extends MessageType {
1061
146
  constructor() {
1062
- super("replit.goval.api.lore.transfer.OrgDestinationAbortRequest", [
147
+ super("replit.goval.api.lore.transfer.OrgSrcTransferOutRequest", [
1063
148
  { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1064
149
  { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1065
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
150
+ { no: 3, name: "signed_url", kind: "message", T: () => SignedUrl },
151
+ { no: 4, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1066
152
  ]);
1067
153
  }
1068
154
  create(value) {
@@ -1084,7 +170,10 @@ class OrgDestinationAbortRequest$Type extends MessageType {
1084
170
  case /* string transfer_id */ 2:
1085
171
  message.transferId = reader.string();
1086
172
  break;
1087
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
173
+ case /* replit.goval.api.lore.transfer.SignedUrl signed_url */ 3:
174
+ message.signedUrl = SignedUrl.internalBinaryRead(reader, reader.uint32(), options, message.signedUrl);
175
+ break;
176
+ case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 4:
1088
177
  message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1089
178
  break;
1090
179
  default:
@@ -1105,9 +194,12 @@ class OrgDestinationAbortRequest$Type extends MessageType {
1105
194
  /* string transfer_id = 2; */
1106
195
  if (message.transferId !== "")
1107
196
  writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1108
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
197
+ /* replit.goval.api.lore.transfer.SignedUrl signed_url = 3; */
198
+ if (message.signedUrl)
199
+ SignedUrl.internalBinaryWrite(message.signedUrl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
200
+ /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 4; */
1109
201
  if (message.principal)
1110
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
202
+ OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
1111
203
  let u = options.writeUnknownFields;
1112
204
  if (u !== false)
1113
205
  (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1115,14 +207,15 @@ class OrgDestinationAbortRequest$Type extends MessageType {
1115
207
  }
1116
208
  }
1117
209
  /**
1118
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAbortRequest
210
+ * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSrcTransferOutRequest
1119
211
  */
1120
- export const OrgDestinationAbortRequest = new OrgDestinationAbortRequest$Type();
212
+ export const OrgSrcTransferOutRequest = new OrgSrcTransferOutRequest$Type();
1121
213
  // @generated message type with reflection information, may provide speed optimized methods
1122
- class OrgDestinationAbortResponse$Type extends MessageType {
214
+ class OrgSrcTransferOutResponse$Type extends MessageType {
1123
215
  constructor() {
1124
- super("replit.goval.api.lore.transfer.OrgDestinationAbortResponse", [
1125
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
216
+ super("replit.goval.api.lore.transfer.OrgSrcTransferOutResponse", [
217
+ { no: 1, name: "status", kind: "message", T: () => PhaseResponse },
218
+ { no: 2, name: "exported", kind: "message", T: () => ExportMetadata }
1126
219
  ]);
1127
220
  }
1128
221
  create(value) {
@@ -1136,8 +229,11 @@ class OrgDestinationAbortResponse$Type extends MessageType {
1136
229
  while (reader.pos < end) {
1137
230
  let [fieldNo, wireType] = reader.tag();
1138
231
  switch (fieldNo) {
1139
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1140
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
232
+ case /* replit.goval.api.lore.transfer.PhaseResponse status */ 1:
233
+ message.status = PhaseResponse.internalBinaryRead(reader, reader.uint32(), options, message.status);
234
+ break;
235
+ case /* replit.goval.api.lore.transfer.ExportMetadata exported */ 2:
236
+ message.exported = ExportMetadata.internalBinaryRead(reader, reader.uint32(), options, message.exported);
1141
237
  break;
1142
238
  default:
1143
239
  let u = options.readUnknownField;
@@ -1151,9 +247,12 @@ class OrgDestinationAbortResponse$Type extends MessageType {
1151
247
  return message;
1152
248
  }
1153
249
  internalBinaryWrite(message, writer, options) {
1154
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
250
+ /* replit.goval.api.lore.transfer.PhaseResponse status = 1; */
1155
251
  if (message.status)
1156
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
252
+ PhaseResponse.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
253
+ /* replit.goval.api.lore.transfer.ExportMetadata exported = 2; */
254
+ if (message.exported)
255
+ ExportMetadata.internalBinaryWrite(message.exported, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
1157
256
  let u = options.writeUnknownFields;
1158
257
  if (u !== false)
1159
258
  (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1161,16 +260,18 @@ class OrgDestinationAbortResponse$Type extends MessageType {
1161
260
  }
1162
261
  }
1163
262
  /**
1164
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDestinationAbortResponse
263
+ * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSrcTransferOutResponse
1165
264
  */
1166
- export const OrgDestinationAbortResponse = new OrgDestinationAbortResponse$Type();
265
+ export const OrgSrcTransferOutResponse = new OrgSrcTransferOutResponse$Type();
1167
266
  // @generated message type with reflection information, may provide speed optimized methods
1168
- class OrgSourceCleanUpTransferDataRequest$Type extends MessageType {
267
+ class OrgDstTransferInRequest$Type extends MessageType {
1169
268
  constructor() {
1170
- super("replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataRequest", [
269
+ super("replit.goval.api.lore.transfer.OrgDstTransferInRequest", [
1171
270
  { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1172
271
  { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1173
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
272
+ { no: 3, name: "signed_url", kind: "message", T: () => SignedUrl },
273
+ { no: 4, name: "ttl", kind: "message", T: () => Duration },
274
+ { no: 5, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1174
275
  ]);
1175
276
  }
1176
277
  create(value) {
@@ -1192,7 +293,13 @@ class OrgSourceCleanUpTransferDataRequest$Type extends MessageType {
1192
293
  case /* string transfer_id */ 2:
1193
294
  message.transferId = reader.string();
1194
295
  break;
1195
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
296
+ case /* replit.goval.api.lore.transfer.SignedUrl signed_url */ 3:
297
+ message.signedUrl = SignedUrl.internalBinaryRead(reader, reader.uint32(), options, message.signedUrl);
298
+ break;
299
+ case /* google.protobuf.Duration ttl */ 4:
300
+ message.ttl = Duration.internalBinaryRead(reader, reader.uint32(), options, message.ttl);
301
+ break;
302
+ case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 5:
1196
303
  message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1197
304
  break;
1198
305
  default:
@@ -1213,55 +320,15 @@ class OrgSourceCleanUpTransferDataRequest$Type extends MessageType {
1213
320
  /* string transfer_id = 2; */
1214
321
  if (message.transferId !== "")
1215
322
  writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1216
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
323
+ /* replit.goval.api.lore.transfer.SignedUrl signed_url = 3; */
324
+ if (message.signedUrl)
325
+ SignedUrl.internalBinaryWrite(message.signedUrl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
326
+ /* google.protobuf.Duration ttl = 4; */
327
+ if (message.ttl)
328
+ Duration.internalBinaryWrite(message.ttl, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
329
+ /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 5; */
1217
330
  if (message.principal)
1218
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
1219
- let u = options.writeUnknownFields;
1220
- if (u !== false)
1221
- (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
1222
- return writer;
1223
- }
1224
- }
1225
- /**
1226
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataRequest
1227
- */
1228
- export const OrgSourceCleanUpTransferDataRequest = new OrgSourceCleanUpTransferDataRequest$Type();
1229
- // @generated message type with reflection information, may provide speed optimized methods
1230
- class OrgSourceCleanUpTransferDataResponse$Type extends MessageType {
1231
- constructor() {
1232
- super("replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataResponse", [
1233
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
1234
- ]);
1235
- }
1236
- create(value) {
1237
- const message = globalThis.Object.create((this.messagePrototype));
1238
- if (value !== undefined)
1239
- reflectionMergePartial(this, message, value);
1240
- return message;
1241
- }
1242
- internalBinaryRead(reader, length, options, target) {
1243
- let message = target ?? this.create(), end = reader.pos + length;
1244
- while (reader.pos < end) {
1245
- let [fieldNo, wireType] = reader.tag();
1246
- switch (fieldNo) {
1247
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1248
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
1249
- break;
1250
- default:
1251
- let u = options.readUnknownField;
1252
- if (u === "throw")
1253
- throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
1254
- let d = reader.skip(wireType);
1255
- if (u !== false)
1256
- (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
1257
- }
1258
- }
1259
- return message;
1260
- }
1261
- internalBinaryWrite(message, writer, options) {
1262
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1263
- if (message.status)
1264
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
331
+ OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
1265
332
  let u = options.writeUnknownFields;
1266
333
  if (u !== false)
1267
334
  (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1269,16 +336,17 @@ class OrgSourceCleanUpTransferDataResponse$Type extends MessageType {
1269
336
  }
1270
337
  }
1271
338
  /**
1272
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceCleanUpTransferDataResponse
339
+ * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDstTransferInRequest
1273
340
  */
1274
- export const OrgSourceCleanUpTransferDataResponse = new OrgSourceCleanUpTransferDataResponse$Type();
341
+ export const OrgDstTransferInRequest = new OrgDstTransferInRequest$Type();
1275
342
  // @generated message type with reflection information, may provide speed optimized methods
1276
- class OrgSourceDeleteRequest$Type extends MessageType {
343
+ class OrgDstAbortDiscardImportRequest$Type extends MessageType {
1277
344
  constructor() {
1278
- super("replit.goval.api.lore.transfer.OrgSourceDeleteRequest", [
345
+ super("replit.goval.api.lore.transfer.OrgDstAbortDiscardImportRequest", [
1279
346
  { no: 1, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1280
347
  { no: 2, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
1281
- { no: 3, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
348
+ { no: 3, name: "signed_url", kind: "message", T: () => SignedUrl },
349
+ { no: 4, name: "principal", kind: "message", T: () => OrgTransferPrincipal }
1282
350
  ]);
1283
351
  }
1284
352
  create(value) {
@@ -1300,7 +368,10 @@ class OrgSourceDeleteRequest$Type extends MessageType {
1300
368
  case /* string transfer_id */ 2:
1301
369
  message.transferId = reader.string();
1302
370
  break;
1303
- case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 3:
371
+ case /* replit.goval.api.lore.transfer.SignedUrl signed_url */ 3:
372
+ message.signedUrl = SignedUrl.internalBinaryRead(reader, reader.uint32(), options, message.signedUrl);
373
+ break;
374
+ case /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal */ 4:
1304
375
  message.principal = OrgTransferPrincipal.internalBinaryRead(reader, reader.uint32(), options, message.principal);
1305
376
  break;
1306
377
  default:
@@ -1321,9 +392,12 @@ class OrgSourceDeleteRequest$Type extends MessageType {
1321
392
  /* string transfer_id = 2; */
1322
393
  if (message.transferId !== "")
1323
394
  writer.tag(2, WireType.LengthDelimited).string(message.transferId);
1324
- /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 3; */
395
+ /* replit.goval.api.lore.transfer.SignedUrl signed_url = 3; */
396
+ if (message.signedUrl)
397
+ SignedUrl.internalBinaryWrite(message.signedUrl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
398
+ /* replit.goval.api.lore.transfer.OrgTransferPrincipal principal = 4; */
1325
399
  if (message.principal)
1326
- OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
400
+ OrgTransferPrincipal.internalBinaryWrite(message.principal, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
1327
401
  let u = options.writeUnknownFields;
1328
402
  if (u !== false)
1329
403
  (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1331,18 +405,20 @@ class OrgSourceDeleteRequest$Type extends MessageType {
1331
405
  }
1332
406
  }
1333
407
  /**
1334
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceDeleteRequest
408
+ * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgDstAbortDiscardImportRequest
1335
409
  */
1336
- export const OrgSourceDeleteRequest = new OrgSourceDeleteRequest$Type();
410
+ export const OrgDstAbortDiscardImportRequest = new OrgDstAbortDiscardImportRequest$Type();
1337
411
  // @generated message type with reflection information, may provide speed optimized methods
1338
- class OrgSourceDeleteResponse$Type extends MessageType {
412
+ class OrgTransferPrincipal$Type extends MessageType {
1339
413
  constructor() {
1340
- super("replit.goval.api.lore.transfer.OrgSourceDeleteResponse", [
1341
- { no: 1, name: "status", kind: "message", T: () => OrgResponseStatus }
414
+ super("replit.goval.api.lore.transfer.OrgTransferPrincipal", [
415
+ { no: 1, name: "user_id", kind: "scalar", oneof: "principal", T: 13 /*ScalarType.UINT32*/ },
416
+ { no: 2, name: "service_id", kind: "scalar", oneof: "principal", T: 9 /*ScalarType.STRING*/ }
1342
417
  ]);
1343
418
  }
1344
419
  create(value) {
1345
420
  const message = globalThis.Object.create((this.messagePrototype));
421
+ message.principal = { oneofKind: undefined };
1346
422
  if (value !== undefined)
1347
423
  reflectionMergePartial(this, message, value);
1348
424
  return message;
@@ -1352,8 +428,17 @@ class OrgSourceDeleteResponse$Type extends MessageType {
1352
428
  while (reader.pos < end) {
1353
429
  let [fieldNo, wireType] = reader.tag();
1354
430
  switch (fieldNo) {
1355
- case /* replit.goval.api.lore.transfer.OrgResponseStatus status */ 1:
1356
- message.status = OrgResponseStatus.internalBinaryRead(reader, reader.uint32(), options, message.status);
431
+ case /* uint32 user_id */ 1:
432
+ message.principal = {
433
+ oneofKind: "userId",
434
+ userId: reader.uint32()
435
+ };
436
+ break;
437
+ case /* string service_id */ 2:
438
+ message.principal = {
439
+ oneofKind: "serviceId",
440
+ serviceId: reader.string()
441
+ };
1357
442
  break;
1358
443
  default:
1359
444
  let u = options.readUnknownField;
@@ -1367,9 +452,12 @@ class OrgSourceDeleteResponse$Type extends MessageType {
1367
452
  return message;
1368
453
  }
1369
454
  internalBinaryWrite(message, writer, options) {
1370
- /* replit.goval.api.lore.transfer.OrgResponseStatus status = 1; */
1371
- if (message.status)
1372
- OrgResponseStatus.internalBinaryWrite(message.status, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
455
+ /* uint32 user_id = 1; */
456
+ if (message.principal.oneofKind === "userId")
457
+ writer.tag(1, WireType.Varint).uint32(message.principal.userId);
458
+ /* string service_id = 2; */
459
+ if (message.principal.oneofKind === "serviceId")
460
+ writer.tag(2, WireType.LengthDelimited).string(message.principal.serviceId);
1373
461
  let u = options.writeUnknownFields;
1374
462
  if (u !== false)
1375
463
  (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -1377,22 +465,19 @@ class OrgSourceDeleteResponse$Type extends MessageType {
1377
465
  }
1378
466
  }
1379
467
  /**
1380
- * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgSourceDeleteResponse
468
+ * @generated MessageType for protobuf message replit.goval.api.lore.transfer.OrgTransferPrincipal
1381
469
  */
1382
- export const OrgSourceDeleteResponse = new OrgSourceDeleteResponse$Type();
470
+ export const OrgTransferPrincipal = new OrgTransferPrincipal$Type();
1383
471
  /**
1384
472
  * @generated ServiceType for protobuf service replit.goval.api.lore.transfer.TransferOrgHomeCell
1385
473
  */
1386
474
  export const TransferOrgHomeCell = new ServiceType("replit.goval.api.lore.transfer.TransferOrgHomeCell", [
1387
- { name: "SourceStopAndDrain", options: {}, I: OrgSourceStopAndDrainRequest, O: OrgSourceStopAndDrainResponse },
1388
- { name: "IsSourceFullyDrained", options: {}, I: OrgIsSourceFullyDrainedRequest, O: OrgIsSourceFullyDrainedResponse },
1389
- { name: "SourceRemoveTombstone", options: {}, I: OrgSourceRemoveTombstoneRequest, O: OrgSourceRemoveTombstoneResponse },
1390
- { name: "SourceTransferOut", options: {}, I: OrgSourceTransferOutRequest, O: OrgSourceTransferOutResponse },
1391
- { name: "DestinationTransferIn", options: {}, I: OrgDestinationTransferInRequest, O: OrgDestinationTransferInResponse },
1392
- { name: "DestinationAddTombstone", options: {}, I: OrgDestinationAddTombstoneRequest, O: OrgDestinationAddTombstoneResponse },
1393
- { name: "DestinationRemoveTombstone", options: {}, I: OrgDestinationRemoveTombstoneRequest, O: OrgDestinationRemoveTombstoneResponse },
1394
- { name: "SourceAbort", options: {}, I: OrgSourceAbortRequest, O: OrgSourceAbortResponse },
1395
- { name: "DestinationAbort", options: {}, I: OrgDestinationAbortRequest, O: OrgDestinationAbortResponse },
1396
- { name: "SourceCleanUpTransferData", options: {}, I: OrgSourceCleanUpTransferDataRequest, O: OrgSourceCleanUpTransferDataResponse },
1397
- { name: "SourceDelete", options: {}, I: OrgSourceDeleteRequest, O: OrgSourceDeleteResponse }
475
+ { name: "SrcStopAndDrain", options: {}, I: OrgSrcStopAndDrainRequest, O: PhaseResponse },
476
+ { name: "SrcTransferOut", options: {}, I: OrgSrcTransferOutRequest, O: OrgSrcTransferOutResponse },
477
+ { name: "DstTransferIn", options: {}, I: OrgDstTransferInRequest, O: PhaseResponse },
478
+ { name: "SrcCancelExport", options: {}, I: OrgTransferRequest, O: PhaseResponse },
479
+ { name: "SrcResume", options: {}, I: OrgTransferRequest, O: PhaseResponse },
480
+ { name: "DstAbortDiscardImport", options: {}, I: OrgDstAbortDiscardImportRequest, O: PhaseResponse },
481
+ { name: "DstActivate", options: {}, I: OrgTransferRequest, O: PhaseResponse },
482
+ { name: "SrcDelete", options: {}, I: OrgTransferRequest, O: PhaseResponse }
1398
483
  ]);