kurtosis-sdk 0.49.5

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.
Files changed (69) hide show
  1. package/build/core/kurtosis_core_rpc_api_bindings/api_container_service_grpc_pb.d.ts +110 -0
  2. package/build/core/kurtosis_core_rpc_api_bindings/api_container_service_grpc_pb.js +581 -0
  3. package/build/core/kurtosis_core_rpc_api_bindings/api_container_service_grpc_web_pb.d.ts +236 -0
  4. package/build/core/kurtosis_core_rpc_api_bindings/api_container_service_grpc_web_pb.js +1174 -0
  5. package/build/core/kurtosis_core_rpc_api_bindings/api_container_service_pb.d.ts +918 -0
  6. package/build/core/kurtosis_core_rpc_api_bindings/api_container_service_pb.js +7616 -0
  7. package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_pb.d.ts +30 -0
  8. package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_pb.js +70 -0
  9. package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_web_pb.d.ts +44 -0
  10. package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_grpc_web_pb.js +198 -0
  11. package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_pb.d.ts +41 -0
  12. package/build/core/kurtosis_core_rpc_api_bindings/executable_module_service_pb.js +324 -0
  13. package/build/core/lib/constructor_calls.d.ts +33 -0
  14. package/build/core/lib/constructor_calls.js +328 -0
  15. package/build/core/lib/enclaves/enclave_context.d.ts +39 -0
  16. package/build/core/lib/enclaves/enclave_context.js +501 -0
  17. package/build/core/lib/enclaves/generic_api_container_client.d.ts +23 -0
  18. package/build/core/lib/enclaves/generic_api_container_client.js +6 -0
  19. package/build/core/lib/enclaves/generic_path_joiner.d.ts +3 -0
  20. package/build/core/lib/enclaves/generic_path_joiner.js +6 -0
  21. package/build/core/lib/enclaves/generic_tgz_archiver.d.ts +4 -0
  22. package/build/core/lib/enclaves/generic_tgz_archiver.js +2 -0
  23. package/build/core/lib/enclaves/grpc_node_api_container_client.d.ts +29 -0
  24. package/build/core/lib/enclaves/grpc_node_api_container_client.js +415 -0
  25. package/build/core/lib/enclaves/grpc_web_api_container_client.d.ts +28 -0
  26. package/build/core/lib/enclaves/grpc_web_api_container_client.js +415 -0
  27. package/build/core/lib/enclaves/node_tgz_archiver.d.ts +6 -0
  28. package/build/core/lib/enclaves/node_tgz_archiver.js +94 -0
  29. package/build/core/lib/enclaves/partition_connection.d.ts +20 -0
  30. package/build/core/lib/enclaves/partition_connection.js +62 -0
  31. package/build/core/lib/enclaves/template_and_data.d.ts +5 -0
  32. package/build/core/lib/enclaves/template_and_data.js +11 -0
  33. package/build/core/lib/enclaves/web_tgz_archiver.d.ts +5 -0
  34. package/build/core/lib/enclaves/web_tgz_archiver.js +26 -0
  35. package/build/core/lib/modules/module_context.d.ts +9 -0
  36. package/build/core/lib/modules/module_context.js +34 -0
  37. package/build/core/lib/services/container_config.d.ts +39 -0
  38. package/build/core/lib/services/container_config.js +85 -0
  39. package/build/core/lib/services/port_spec.d.ts +11 -0
  40. package/build/core/lib/services/port_spec.js +16 -0
  41. package/build/core/lib/services/service.d.ts +1 -0
  42. package/build/core/lib/services/service.js +6 -0
  43. package/build/core/lib/services/service_context.d.ts +19 -0
  44. package/build/core/lib/services/service_context.js +58 -0
  45. package/build/core/module_launch_api/args_io.d.ts +4 -0
  46. package/build/core/module_launch_api/args_io.js +60 -0
  47. package/build/core/module_launch_api/module_container_args.d.ts +8 -0
  48. package/build/core/module_launch_api/module_container_args.js +24 -0
  49. package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_grpc_pb.d.ts +50 -0
  50. package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_grpc_pb.js +186 -0
  51. package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_grpc_web_pb.d.ts +92 -0
  52. package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_grpc_web_pb.js +442 -0
  53. package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_pb.d.ts +267 -0
  54. package/build/engine/kurtosis_engine_rpc_api_bindings/engine_service_pb.js +2141 -0
  55. package/build/engine/lib/constructor_calls.d.ts +5 -0
  56. package/build/engine/lib/constructor_calls.js +34 -0
  57. package/build/engine/lib/kurtosis_context/generic_engine_client.d.ts +10 -0
  58. package/build/engine/lib/kurtosis_context/generic_engine_client.js +2 -0
  59. package/build/engine/lib/kurtosis_context/grpc_node_engine_client.d.ts +14 -0
  60. package/build/engine/lib/kurtosis_context/grpc_node_engine_client.js +165 -0
  61. package/build/engine/lib/kurtosis_context/grpc_web_engine_client.d.ts +14 -0
  62. package/build/engine/lib/kurtosis_context/grpc_web_engine_client.js +165 -0
  63. package/build/engine/lib/kurtosis_context/kurtosis_context.d.ts +19 -0
  64. package/build/engine/lib/kurtosis_context/kurtosis_context.js +236 -0
  65. package/build/index.d.ts +19 -0
  66. package/build/index.js +55 -0
  67. package/build/kurtosis_version/kurtosis_version.d.ts +1 -0
  68. package/build/kurtosis_version/kurtosis_version.js +8 -0
  69. package/package.json +59 -0
@@ -0,0 +1,2141 @@
1
+ // source: engine_service.proto
2
+ /**
3
+ * @fileoverview
4
+ * @enhanceable
5
+ * @suppress {missingRequire} reports error on implicit type usages.
6
+ * @suppress {messageConventions} JS Compiler reports an error if a variable or
7
+ * field starts with 'MSG_' and isn't a translatable message.
8
+ * @public
9
+ */
10
+ // GENERATED CODE -- DO NOT EDIT!
11
+ /* eslint-disable */
12
+ // @ts-nocheck
13
+
14
+ var jspb = require('google-protobuf');
15
+ var goog = jspb;
16
+ var global = Function('return this')();
17
+
18
+ var google_protobuf_empty_pb = require('google-protobuf/google/protobuf/empty_pb.js');
19
+ goog.object.extend(proto, google_protobuf_empty_pb);
20
+ goog.exportSymbol('proto.engine_api.CleanArgs', null, global);
21
+ goog.exportSymbol('proto.engine_api.CleanResponse', null, global);
22
+ goog.exportSymbol('proto.engine_api.CreateEnclaveArgs', null, global);
23
+ goog.exportSymbol('proto.engine_api.CreateEnclaveResponse', null, global);
24
+ goog.exportSymbol('proto.engine_api.DestroyEnclaveArgs', null, global);
25
+ goog.exportSymbol('proto.engine_api.EnclaveAPIContainerHostMachineInfo', null, global);
26
+ goog.exportSymbol('proto.engine_api.EnclaveAPIContainerInfo', null, global);
27
+ goog.exportSymbol('proto.engine_api.EnclaveAPIContainerStatus', null, global);
28
+ goog.exportSymbol('proto.engine_api.EnclaveContainersStatus', null, global);
29
+ goog.exportSymbol('proto.engine_api.EnclaveInfo', null, global);
30
+ goog.exportSymbol('proto.engine_api.GetEnclavesResponse', null, global);
31
+ goog.exportSymbol('proto.engine_api.GetEngineInfoResponse', null, global);
32
+ goog.exportSymbol('proto.engine_api.StopEnclaveArgs', null, global);
33
+ /**
34
+ * Generated by JsPbCodeGenerator.
35
+ * @param {Array=} opt_data Optional initial data array, typically from a
36
+ * server response, or constructed directly in Javascript. The array is used
37
+ * in place and becomes part of the constructed object. It is not cloned.
38
+ * If no data is provided, the constructed object will be empty, but still
39
+ * valid.
40
+ * @extends {jspb.Message}
41
+ * @constructor
42
+ */
43
+ proto.engine_api.GetEngineInfoResponse = function(opt_data) {
44
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
45
+ };
46
+ goog.inherits(proto.engine_api.GetEngineInfoResponse, jspb.Message);
47
+ if (goog.DEBUG && !COMPILED) {
48
+ /**
49
+ * @public
50
+ * @override
51
+ */
52
+ proto.engine_api.GetEngineInfoResponse.displayName = 'proto.engine_api.GetEngineInfoResponse';
53
+ }
54
+ /**
55
+ * Generated by JsPbCodeGenerator.
56
+ * @param {Array=} opt_data Optional initial data array, typically from a
57
+ * server response, or constructed directly in Javascript. The array is used
58
+ * in place and becomes part of the constructed object. It is not cloned.
59
+ * If no data is provided, the constructed object will be empty, but still
60
+ * valid.
61
+ * @extends {jspb.Message}
62
+ * @constructor
63
+ */
64
+ proto.engine_api.CreateEnclaveArgs = function(opt_data) {
65
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
66
+ };
67
+ goog.inherits(proto.engine_api.CreateEnclaveArgs, jspb.Message);
68
+ if (goog.DEBUG && !COMPILED) {
69
+ /**
70
+ * @public
71
+ * @override
72
+ */
73
+ proto.engine_api.CreateEnclaveArgs.displayName = 'proto.engine_api.CreateEnclaveArgs';
74
+ }
75
+ /**
76
+ * Generated by JsPbCodeGenerator.
77
+ * @param {Array=} opt_data Optional initial data array, typically from a
78
+ * server response, or constructed directly in Javascript. The array is used
79
+ * in place and becomes part of the constructed object. It is not cloned.
80
+ * If no data is provided, the constructed object will be empty, but still
81
+ * valid.
82
+ * @extends {jspb.Message}
83
+ * @constructor
84
+ */
85
+ proto.engine_api.CreateEnclaveResponse = function(opt_data) {
86
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
87
+ };
88
+ goog.inherits(proto.engine_api.CreateEnclaveResponse, jspb.Message);
89
+ if (goog.DEBUG && !COMPILED) {
90
+ /**
91
+ * @public
92
+ * @override
93
+ */
94
+ proto.engine_api.CreateEnclaveResponse.displayName = 'proto.engine_api.CreateEnclaveResponse';
95
+ }
96
+ /**
97
+ * Generated by JsPbCodeGenerator.
98
+ * @param {Array=} opt_data Optional initial data array, typically from a
99
+ * server response, or constructed directly in Javascript. The array is used
100
+ * in place and becomes part of the constructed object. It is not cloned.
101
+ * If no data is provided, the constructed object will be empty, but still
102
+ * valid.
103
+ * @extends {jspb.Message}
104
+ * @constructor
105
+ */
106
+ proto.engine_api.EnclaveAPIContainerInfo = function(opt_data) {
107
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
108
+ };
109
+ goog.inherits(proto.engine_api.EnclaveAPIContainerInfo, jspb.Message);
110
+ if (goog.DEBUG && !COMPILED) {
111
+ /**
112
+ * @public
113
+ * @override
114
+ */
115
+ proto.engine_api.EnclaveAPIContainerInfo.displayName = 'proto.engine_api.EnclaveAPIContainerInfo';
116
+ }
117
+ /**
118
+ * Generated by JsPbCodeGenerator.
119
+ * @param {Array=} opt_data Optional initial data array, typically from a
120
+ * server response, or constructed directly in Javascript. The array is used
121
+ * in place and becomes part of the constructed object. It is not cloned.
122
+ * If no data is provided, the constructed object will be empty, but still
123
+ * valid.
124
+ * @extends {jspb.Message}
125
+ * @constructor
126
+ */
127
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo = function(opt_data) {
128
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
129
+ };
130
+ goog.inherits(proto.engine_api.EnclaveAPIContainerHostMachineInfo, jspb.Message);
131
+ if (goog.DEBUG && !COMPILED) {
132
+ /**
133
+ * @public
134
+ * @override
135
+ */
136
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.displayName = 'proto.engine_api.EnclaveAPIContainerHostMachineInfo';
137
+ }
138
+ /**
139
+ * Generated by JsPbCodeGenerator.
140
+ * @param {Array=} opt_data Optional initial data array, typically from a
141
+ * server response, or constructed directly in Javascript. The array is used
142
+ * in place and becomes part of the constructed object. It is not cloned.
143
+ * If no data is provided, the constructed object will be empty, but still
144
+ * valid.
145
+ * @extends {jspb.Message}
146
+ * @constructor
147
+ */
148
+ proto.engine_api.EnclaveInfo = function(opt_data) {
149
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
150
+ };
151
+ goog.inherits(proto.engine_api.EnclaveInfo, jspb.Message);
152
+ if (goog.DEBUG && !COMPILED) {
153
+ /**
154
+ * @public
155
+ * @override
156
+ */
157
+ proto.engine_api.EnclaveInfo.displayName = 'proto.engine_api.EnclaveInfo';
158
+ }
159
+ /**
160
+ * Generated by JsPbCodeGenerator.
161
+ * @param {Array=} opt_data Optional initial data array, typically from a
162
+ * server response, or constructed directly in Javascript. The array is used
163
+ * in place and becomes part of the constructed object. It is not cloned.
164
+ * If no data is provided, the constructed object will be empty, but still
165
+ * valid.
166
+ * @extends {jspb.Message}
167
+ * @constructor
168
+ */
169
+ proto.engine_api.GetEnclavesResponse = function(opt_data) {
170
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
171
+ };
172
+ goog.inherits(proto.engine_api.GetEnclavesResponse, jspb.Message);
173
+ if (goog.DEBUG && !COMPILED) {
174
+ /**
175
+ * @public
176
+ * @override
177
+ */
178
+ proto.engine_api.GetEnclavesResponse.displayName = 'proto.engine_api.GetEnclavesResponse';
179
+ }
180
+ /**
181
+ * Generated by JsPbCodeGenerator.
182
+ * @param {Array=} opt_data Optional initial data array, typically from a
183
+ * server response, or constructed directly in Javascript. The array is used
184
+ * in place and becomes part of the constructed object. It is not cloned.
185
+ * If no data is provided, the constructed object will be empty, but still
186
+ * valid.
187
+ * @extends {jspb.Message}
188
+ * @constructor
189
+ */
190
+ proto.engine_api.StopEnclaveArgs = function(opt_data) {
191
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
192
+ };
193
+ goog.inherits(proto.engine_api.StopEnclaveArgs, jspb.Message);
194
+ if (goog.DEBUG && !COMPILED) {
195
+ /**
196
+ * @public
197
+ * @override
198
+ */
199
+ proto.engine_api.StopEnclaveArgs.displayName = 'proto.engine_api.StopEnclaveArgs';
200
+ }
201
+ /**
202
+ * Generated by JsPbCodeGenerator.
203
+ * @param {Array=} opt_data Optional initial data array, typically from a
204
+ * server response, or constructed directly in Javascript. The array is used
205
+ * in place and becomes part of the constructed object. It is not cloned.
206
+ * If no data is provided, the constructed object will be empty, but still
207
+ * valid.
208
+ * @extends {jspb.Message}
209
+ * @constructor
210
+ */
211
+ proto.engine_api.DestroyEnclaveArgs = function(opt_data) {
212
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
213
+ };
214
+ goog.inherits(proto.engine_api.DestroyEnclaveArgs, jspb.Message);
215
+ if (goog.DEBUG && !COMPILED) {
216
+ /**
217
+ * @public
218
+ * @override
219
+ */
220
+ proto.engine_api.DestroyEnclaveArgs.displayName = 'proto.engine_api.DestroyEnclaveArgs';
221
+ }
222
+ /**
223
+ * Generated by JsPbCodeGenerator.
224
+ * @param {Array=} opt_data Optional initial data array, typically from a
225
+ * server response, or constructed directly in Javascript. The array is used
226
+ * in place and becomes part of the constructed object. It is not cloned.
227
+ * If no data is provided, the constructed object will be empty, but still
228
+ * valid.
229
+ * @extends {jspb.Message}
230
+ * @constructor
231
+ */
232
+ proto.engine_api.CleanArgs = function(opt_data) {
233
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
234
+ };
235
+ goog.inherits(proto.engine_api.CleanArgs, jspb.Message);
236
+ if (goog.DEBUG && !COMPILED) {
237
+ /**
238
+ * @public
239
+ * @override
240
+ */
241
+ proto.engine_api.CleanArgs.displayName = 'proto.engine_api.CleanArgs';
242
+ }
243
+ /**
244
+ * Generated by JsPbCodeGenerator.
245
+ * @param {Array=} opt_data Optional initial data array, typically from a
246
+ * server response, or constructed directly in Javascript. The array is used
247
+ * in place and becomes part of the constructed object. It is not cloned.
248
+ * If no data is provided, the constructed object will be empty, but still
249
+ * valid.
250
+ * @extends {jspb.Message}
251
+ * @constructor
252
+ */
253
+ proto.engine_api.CleanResponse = function(opt_data) {
254
+ jspb.Message.initialize(this, opt_data, 0, -1, null, null);
255
+ };
256
+ goog.inherits(proto.engine_api.CleanResponse, jspb.Message);
257
+ if (goog.DEBUG && !COMPILED) {
258
+ /**
259
+ * @public
260
+ * @override
261
+ */
262
+ proto.engine_api.CleanResponse.displayName = 'proto.engine_api.CleanResponse';
263
+ }
264
+
265
+
266
+
267
+ if (jspb.Message.GENERATE_TO_OBJECT) {
268
+ /**
269
+ * Creates an object representation of this proto.
270
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
271
+ * Optional fields that are not set will be set to undefined.
272
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
273
+ * For the list of reserved names please see:
274
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
275
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
276
+ * JSPB instance for transitional soy proto support:
277
+ * http://goto/soy-param-migration
278
+ * @return {!Object}
279
+ */
280
+ proto.engine_api.GetEngineInfoResponse.prototype.toObject = function(opt_includeInstance) {
281
+ return proto.engine_api.GetEngineInfoResponse.toObject(opt_includeInstance, this);
282
+ };
283
+
284
+
285
+ /**
286
+ * Static version of the {@see toObject} method.
287
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
288
+ * the JSPB instance for transitional soy proto support:
289
+ * http://goto/soy-param-migration
290
+ * @param {!proto.engine_api.GetEngineInfoResponse} msg The msg instance to transform.
291
+ * @return {!Object}
292
+ * @suppress {unusedLocalVariables} f is only used for nested messages
293
+ */
294
+ proto.engine_api.GetEngineInfoResponse.toObject = function(includeInstance, msg) {
295
+ var f, obj = {
296
+ engineVersion: jspb.Message.getFieldWithDefault(msg, 1, "")
297
+ };
298
+
299
+ if (includeInstance) {
300
+ obj.$jspbMessageInstance = msg;
301
+ }
302
+ return obj;
303
+ };
304
+ }
305
+
306
+
307
+ /**
308
+ * Deserializes binary data (in protobuf wire format).
309
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
310
+ * @return {!proto.engine_api.GetEngineInfoResponse}
311
+ */
312
+ proto.engine_api.GetEngineInfoResponse.deserializeBinary = function(bytes) {
313
+ var reader = new jspb.BinaryReader(bytes);
314
+ var msg = new proto.engine_api.GetEngineInfoResponse;
315
+ return proto.engine_api.GetEngineInfoResponse.deserializeBinaryFromReader(msg, reader);
316
+ };
317
+
318
+
319
+ /**
320
+ * Deserializes binary data (in protobuf wire format) from the
321
+ * given reader into the given message object.
322
+ * @param {!proto.engine_api.GetEngineInfoResponse} msg The message object to deserialize into.
323
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
324
+ * @return {!proto.engine_api.GetEngineInfoResponse}
325
+ */
326
+ proto.engine_api.GetEngineInfoResponse.deserializeBinaryFromReader = function(msg, reader) {
327
+ while (reader.nextField()) {
328
+ if (reader.isEndGroup()) {
329
+ break;
330
+ }
331
+ var field = reader.getFieldNumber();
332
+ switch (field) {
333
+ case 1:
334
+ var value = /** @type {string} */ (reader.readString());
335
+ msg.setEngineVersion(value);
336
+ break;
337
+ default:
338
+ reader.skipField();
339
+ break;
340
+ }
341
+ }
342
+ return msg;
343
+ };
344
+
345
+
346
+ /**
347
+ * Serializes the message to binary data (in protobuf wire format).
348
+ * @return {!Uint8Array}
349
+ */
350
+ proto.engine_api.GetEngineInfoResponse.prototype.serializeBinary = function() {
351
+ var writer = new jspb.BinaryWriter();
352
+ proto.engine_api.GetEngineInfoResponse.serializeBinaryToWriter(this, writer);
353
+ return writer.getResultBuffer();
354
+ };
355
+
356
+
357
+ /**
358
+ * Serializes the given message to binary data (in protobuf wire
359
+ * format), writing to the given BinaryWriter.
360
+ * @param {!proto.engine_api.GetEngineInfoResponse} message
361
+ * @param {!jspb.BinaryWriter} writer
362
+ * @suppress {unusedLocalVariables} f is only used for nested messages
363
+ */
364
+ proto.engine_api.GetEngineInfoResponse.serializeBinaryToWriter = function(message, writer) {
365
+ var f = undefined;
366
+ f = message.getEngineVersion();
367
+ if (f.length > 0) {
368
+ writer.writeString(
369
+ 1,
370
+ f
371
+ );
372
+ }
373
+ };
374
+
375
+
376
+ /**
377
+ * optional string engine_version = 1;
378
+ * @return {string}
379
+ */
380
+ proto.engine_api.GetEngineInfoResponse.prototype.getEngineVersion = function() {
381
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
382
+ };
383
+
384
+
385
+ /**
386
+ * @param {string} value
387
+ * @return {!proto.engine_api.GetEngineInfoResponse} returns this
388
+ */
389
+ proto.engine_api.GetEngineInfoResponse.prototype.setEngineVersion = function(value) {
390
+ return jspb.Message.setProto3StringField(this, 1, value);
391
+ };
392
+
393
+
394
+
395
+
396
+
397
+ if (jspb.Message.GENERATE_TO_OBJECT) {
398
+ /**
399
+ * Creates an object representation of this proto.
400
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
401
+ * Optional fields that are not set will be set to undefined.
402
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
403
+ * For the list of reserved names please see:
404
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
405
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
406
+ * JSPB instance for transitional soy proto support:
407
+ * http://goto/soy-param-migration
408
+ * @return {!Object}
409
+ */
410
+ proto.engine_api.CreateEnclaveArgs.prototype.toObject = function(opt_includeInstance) {
411
+ return proto.engine_api.CreateEnclaveArgs.toObject(opt_includeInstance, this);
412
+ };
413
+
414
+
415
+ /**
416
+ * Static version of the {@see toObject} method.
417
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
418
+ * the JSPB instance for transitional soy proto support:
419
+ * http://goto/soy-param-migration
420
+ * @param {!proto.engine_api.CreateEnclaveArgs} msg The msg instance to transform.
421
+ * @return {!Object}
422
+ * @suppress {unusedLocalVariables} f is only used for nested messages
423
+ */
424
+ proto.engine_api.CreateEnclaveArgs.toObject = function(includeInstance, msg) {
425
+ var f, obj = {
426
+ enclaveId: jspb.Message.getFieldWithDefault(msg, 1, ""),
427
+ apiContainerVersionTag: jspb.Message.getFieldWithDefault(msg, 2, ""),
428
+ apiContainerLogLevel: jspb.Message.getFieldWithDefault(msg, 3, ""),
429
+ isPartitioningEnabled: jspb.Message.getBooleanFieldWithDefault(msg, 4, false)
430
+ };
431
+
432
+ if (includeInstance) {
433
+ obj.$jspbMessageInstance = msg;
434
+ }
435
+ return obj;
436
+ };
437
+ }
438
+
439
+
440
+ /**
441
+ * Deserializes binary data (in protobuf wire format).
442
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
443
+ * @return {!proto.engine_api.CreateEnclaveArgs}
444
+ */
445
+ proto.engine_api.CreateEnclaveArgs.deserializeBinary = function(bytes) {
446
+ var reader = new jspb.BinaryReader(bytes);
447
+ var msg = new proto.engine_api.CreateEnclaveArgs;
448
+ return proto.engine_api.CreateEnclaveArgs.deserializeBinaryFromReader(msg, reader);
449
+ };
450
+
451
+
452
+ /**
453
+ * Deserializes binary data (in protobuf wire format) from the
454
+ * given reader into the given message object.
455
+ * @param {!proto.engine_api.CreateEnclaveArgs} msg The message object to deserialize into.
456
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
457
+ * @return {!proto.engine_api.CreateEnclaveArgs}
458
+ */
459
+ proto.engine_api.CreateEnclaveArgs.deserializeBinaryFromReader = function(msg, reader) {
460
+ while (reader.nextField()) {
461
+ if (reader.isEndGroup()) {
462
+ break;
463
+ }
464
+ var field = reader.getFieldNumber();
465
+ switch (field) {
466
+ case 1:
467
+ var value = /** @type {string} */ (reader.readString());
468
+ msg.setEnclaveId(value);
469
+ break;
470
+ case 2:
471
+ var value = /** @type {string} */ (reader.readString());
472
+ msg.setApiContainerVersionTag(value);
473
+ break;
474
+ case 3:
475
+ var value = /** @type {string} */ (reader.readString());
476
+ msg.setApiContainerLogLevel(value);
477
+ break;
478
+ case 4:
479
+ var value = /** @type {boolean} */ (reader.readBool());
480
+ msg.setIsPartitioningEnabled(value);
481
+ break;
482
+ default:
483
+ reader.skipField();
484
+ break;
485
+ }
486
+ }
487
+ return msg;
488
+ };
489
+
490
+
491
+ /**
492
+ * Serializes the message to binary data (in protobuf wire format).
493
+ * @return {!Uint8Array}
494
+ */
495
+ proto.engine_api.CreateEnclaveArgs.prototype.serializeBinary = function() {
496
+ var writer = new jspb.BinaryWriter();
497
+ proto.engine_api.CreateEnclaveArgs.serializeBinaryToWriter(this, writer);
498
+ return writer.getResultBuffer();
499
+ };
500
+
501
+
502
+ /**
503
+ * Serializes the given message to binary data (in protobuf wire
504
+ * format), writing to the given BinaryWriter.
505
+ * @param {!proto.engine_api.CreateEnclaveArgs} message
506
+ * @param {!jspb.BinaryWriter} writer
507
+ * @suppress {unusedLocalVariables} f is only used for nested messages
508
+ */
509
+ proto.engine_api.CreateEnclaveArgs.serializeBinaryToWriter = function(message, writer) {
510
+ var f = undefined;
511
+ f = message.getEnclaveId();
512
+ if (f.length > 0) {
513
+ writer.writeString(
514
+ 1,
515
+ f
516
+ );
517
+ }
518
+ f = message.getApiContainerVersionTag();
519
+ if (f.length > 0) {
520
+ writer.writeString(
521
+ 2,
522
+ f
523
+ );
524
+ }
525
+ f = message.getApiContainerLogLevel();
526
+ if (f.length > 0) {
527
+ writer.writeString(
528
+ 3,
529
+ f
530
+ );
531
+ }
532
+ f = message.getIsPartitioningEnabled();
533
+ if (f) {
534
+ writer.writeBool(
535
+ 4,
536
+ f
537
+ );
538
+ }
539
+ };
540
+
541
+
542
+ /**
543
+ * optional string enclave_id = 1;
544
+ * @return {string}
545
+ */
546
+ proto.engine_api.CreateEnclaveArgs.prototype.getEnclaveId = function() {
547
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
548
+ };
549
+
550
+
551
+ /**
552
+ * @param {string} value
553
+ * @return {!proto.engine_api.CreateEnclaveArgs} returns this
554
+ */
555
+ proto.engine_api.CreateEnclaveArgs.prototype.setEnclaveId = function(value) {
556
+ return jspb.Message.setProto3StringField(this, 1, value);
557
+ };
558
+
559
+
560
+ /**
561
+ * optional string api_container_version_tag = 2;
562
+ * @return {string}
563
+ */
564
+ proto.engine_api.CreateEnclaveArgs.prototype.getApiContainerVersionTag = function() {
565
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
566
+ };
567
+
568
+
569
+ /**
570
+ * @param {string} value
571
+ * @return {!proto.engine_api.CreateEnclaveArgs} returns this
572
+ */
573
+ proto.engine_api.CreateEnclaveArgs.prototype.setApiContainerVersionTag = function(value) {
574
+ return jspb.Message.setProto3StringField(this, 2, value);
575
+ };
576
+
577
+
578
+ /**
579
+ * optional string api_container_log_level = 3;
580
+ * @return {string}
581
+ */
582
+ proto.engine_api.CreateEnclaveArgs.prototype.getApiContainerLogLevel = function() {
583
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 3, ""));
584
+ };
585
+
586
+
587
+ /**
588
+ * @param {string} value
589
+ * @return {!proto.engine_api.CreateEnclaveArgs} returns this
590
+ */
591
+ proto.engine_api.CreateEnclaveArgs.prototype.setApiContainerLogLevel = function(value) {
592
+ return jspb.Message.setProto3StringField(this, 3, value);
593
+ };
594
+
595
+
596
+ /**
597
+ * optional bool is_partitioning_enabled = 4;
598
+ * @return {boolean}
599
+ */
600
+ proto.engine_api.CreateEnclaveArgs.prototype.getIsPartitioningEnabled = function() {
601
+ return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 4, false));
602
+ };
603
+
604
+
605
+ /**
606
+ * @param {boolean} value
607
+ * @return {!proto.engine_api.CreateEnclaveArgs} returns this
608
+ */
609
+ proto.engine_api.CreateEnclaveArgs.prototype.setIsPartitioningEnabled = function(value) {
610
+ return jspb.Message.setProto3BooleanField(this, 4, value);
611
+ };
612
+
613
+
614
+
615
+
616
+
617
+ if (jspb.Message.GENERATE_TO_OBJECT) {
618
+ /**
619
+ * Creates an object representation of this proto.
620
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
621
+ * Optional fields that are not set will be set to undefined.
622
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
623
+ * For the list of reserved names please see:
624
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
625
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
626
+ * JSPB instance for transitional soy proto support:
627
+ * http://goto/soy-param-migration
628
+ * @return {!Object}
629
+ */
630
+ proto.engine_api.CreateEnclaveResponse.prototype.toObject = function(opt_includeInstance) {
631
+ return proto.engine_api.CreateEnclaveResponse.toObject(opt_includeInstance, this);
632
+ };
633
+
634
+
635
+ /**
636
+ * Static version of the {@see toObject} method.
637
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
638
+ * the JSPB instance for transitional soy proto support:
639
+ * http://goto/soy-param-migration
640
+ * @param {!proto.engine_api.CreateEnclaveResponse} msg The msg instance to transform.
641
+ * @return {!Object}
642
+ * @suppress {unusedLocalVariables} f is only used for nested messages
643
+ */
644
+ proto.engine_api.CreateEnclaveResponse.toObject = function(includeInstance, msg) {
645
+ var f, obj = {
646
+ enclaveInfo: (f = msg.getEnclaveInfo()) && proto.engine_api.EnclaveInfo.toObject(includeInstance, f)
647
+ };
648
+
649
+ if (includeInstance) {
650
+ obj.$jspbMessageInstance = msg;
651
+ }
652
+ return obj;
653
+ };
654
+ }
655
+
656
+
657
+ /**
658
+ * Deserializes binary data (in protobuf wire format).
659
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
660
+ * @return {!proto.engine_api.CreateEnclaveResponse}
661
+ */
662
+ proto.engine_api.CreateEnclaveResponse.deserializeBinary = function(bytes) {
663
+ var reader = new jspb.BinaryReader(bytes);
664
+ var msg = new proto.engine_api.CreateEnclaveResponse;
665
+ return proto.engine_api.CreateEnclaveResponse.deserializeBinaryFromReader(msg, reader);
666
+ };
667
+
668
+
669
+ /**
670
+ * Deserializes binary data (in protobuf wire format) from the
671
+ * given reader into the given message object.
672
+ * @param {!proto.engine_api.CreateEnclaveResponse} msg The message object to deserialize into.
673
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
674
+ * @return {!proto.engine_api.CreateEnclaveResponse}
675
+ */
676
+ proto.engine_api.CreateEnclaveResponse.deserializeBinaryFromReader = function(msg, reader) {
677
+ while (reader.nextField()) {
678
+ if (reader.isEndGroup()) {
679
+ break;
680
+ }
681
+ var field = reader.getFieldNumber();
682
+ switch (field) {
683
+ case 1:
684
+ var value = new proto.engine_api.EnclaveInfo;
685
+ reader.readMessage(value,proto.engine_api.EnclaveInfo.deserializeBinaryFromReader);
686
+ msg.setEnclaveInfo(value);
687
+ break;
688
+ default:
689
+ reader.skipField();
690
+ break;
691
+ }
692
+ }
693
+ return msg;
694
+ };
695
+
696
+
697
+ /**
698
+ * Serializes the message to binary data (in protobuf wire format).
699
+ * @return {!Uint8Array}
700
+ */
701
+ proto.engine_api.CreateEnclaveResponse.prototype.serializeBinary = function() {
702
+ var writer = new jspb.BinaryWriter();
703
+ proto.engine_api.CreateEnclaveResponse.serializeBinaryToWriter(this, writer);
704
+ return writer.getResultBuffer();
705
+ };
706
+
707
+
708
+ /**
709
+ * Serializes the given message to binary data (in protobuf wire
710
+ * format), writing to the given BinaryWriter.
711
+ * @param {!proto.engine_api.CreateEnclaveResponse} message
712
+ * @param {!jspb.BinaryWriter} writer
713
+ * @suppress {unusedLocalVariables} f is only used for nested messages
714
+ */
715
+ proto.engine_api.CreateEnclaveResponse.serializeBinaryToWriter = function(message, writer) {
716
+ var f = undefined;
717
+ f = message.getEnclaveInfo();
718
+ if (f != null) {
719
+ writer.writeMessage(
720
+ 1,
721
+ f,
722
+ proto.engine_api.EnclaveInfo.serializeBinaryToWriter
723
+ );
724
+ }
725
+ };
726
+
727
+
728
+ /**
729
+ * optional EnclaveInfo enclave_info = 1;
730
+ * @return {?proto.engine_api.EnclaveInfo}
731
+ */
732
+ proto.engine_api.CreateEnclaveResponse.prototype.getEnclaveInfo = function() {
733
+ return /** @type{?proto.engine_api.EnclaveInfo} */ (
734
+ jspb.Message.getWrapperField(this, proto.engine_api.EnclaveInfo, 1));
735
+ };
736
+
737
+
738
+ /**
739
+ * @param {?proto.engine_api.EnclaveInfo|undefined} value
740
+ * @return {!proto.engine_api.CreateEnclaveResponse} returns this
741
+ */
742
+ proto.engine_api.CreateEnclaveResponse.prototype.setEnclaveInfo = function(value) {
743
+ return jspb.Message.setWrapperField(this, 1, value);
744
+ };
745
+
746
+
747
+ /**
748
+ * Clears the message field making it undefined.
749
+ * @return {!proto.engine_api.CreateEnclaveResponse} returns this
750
+ */
751
+ proto.engine_api.CreateEnclaveResponse.prototype.clearEnclaveInfo = function() {
752
+ return this.setEnclaveInfo(undefined);
753
+ };
754
+
755
+
756
+ /**
757
+ * Returns whether this field is set.
758
+ * @return {boolean}
759
+ */
760
+ proto.engine_api.CreateEnclaveResponse.prototype.hasEnclaveInfo = function() {
761
+ return jspb.Message.getField(this, 1) != null;
762
+ };
763
+
764
+
765
+
766
+
767
+
768
+ if (jspb.Message.GENERATE_TO_OBJECT) {
769
+ /**
770
+ * Creates an object representation of this proto.
771
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
772
+ * Optional fields that are not set will be set to undefined.
773
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
774
+ * For the list of reserved names please see:
775
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
776
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
777
+ * JSPB instance for transitional soy proto support:
778
+ * http://goto/soy-param-migration
779
+ * @return {!Object}
780
+ */
781
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.toObject = function(opt_includeInstance) {
782
+ return proto.engine_api.EnclaveAPIContainerInfo.toObject(opt_includeInstance, this);
783
+ };
784
+
785
+
786
+ /**
787
+ * Static version of the {@see toObject} method.
788
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
789
+ * the JSPB instance for transitional soy proto support:
790
+ * http://goto/soy-param-migration
791
+ * @param {!proto.engine_api.EnclaveAPIContainerInfo} msg The msg instance to transform.
792
+ * @return {!Object}
793
+ * @suppress {unusedLocalVariables} f is only used for nested messages
794
+ */
795
+ proto.engine_api.EnclaveAPIContainerInfo.toObject = function(includeInstance, msg) {
796
+ var f, obj = {
797
+ containerId: jspb.Message.getFieldWithDefault(msg, 1, ""),
798
+ ipInsideEnclave: jspb.Message.getFieldWithDefault(msg, 2, ""),
799
+ grpcPortInsideEnclave: jspb.Message.getFieldWithDefault(msg, 3, 0),
800
+ grpcProxyPortInsideEnclave: jspb.Message.getFieldWithDefault(msg, 4, 0)
801
+ };
802
+
803
+ if (includeInstance) {
804
+ obj.$jspbMessageInstance = msg;
805
+ }
806
+ return obj;
807
+ };
808
+ }
809
+
810
+
811
+ /**
812
+ * Deserializes binary data (in protobuf wire format).
813
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
814
+ * @return {!proto.engine_api.EnclaveAPIContainerInfo}
815
+ */
816
+ proto.engine_api.EnclaveAPIContainerInfo.deserializeBinary = function(bytes) {
817
+ var reader = new jspb.BinaryReader(bytes);
818
+ var msg = new proto.engine_api.EnclaveAPIContainerInfo;
819
+ return proto.engine_api.EnclaveAPIContainerInfo.deserializeBinaryFromReader(msg, reader);
820
+ };
821
+
822
+
823
+ /**
824
+ * Deserializes binary data (in protobuf wire format) from the
825
+ * given reader into the given message object.
826
+ * @param {!proto.engine_api.EnclaveAPIContainerInfo} msg The message object to deserialize into.
827
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
828
+ * @return {!proto.engine_api.EnclaveAPIContainerInfo}
829
+ */
830
+ proto.engine_api.EnclaveAPIContainerInfo.deserializeBinaryFromReader = function(msg, reader) {
831
+ while (reader.nextField()) {
832
+ if (reader.isEndGroup()) {
833
+ break;
834
+ }
835
+ var field = reader.getFieldNumber();
836
+ switch (field) {
837
+ case 1:
838
+ var value = /** @type {string} */ (reader.readString());
839
+ msg.setContainerId(value);
840
+ break;
841
+ case 2:
842
+ var value = /** @type {string} */ (reader.readString());
843
+ msg.setIpInsideEnclave(value);
844
+ break;
845
+ case 3:
846
+ var value = /** @type {number} */ (reader.readUint32());
847
+ msg.setGrpcPortInsideEnclave(value);
848
+ break;
849
+ case 4:
850
+ var value = /** @type {number} */ (reader.readUint32());
851
+ msg.setGrpcProxyPortInsideEnclave(value);
852
+ break;
853
+ default:
854
+ reader.skipField();
855
+ break;
856
+ }
857
+ }
858
+ return msg;
859
+ };
860
+
861
+
862
+ /**
863
+ * Serializes the message to binary data (in protobuf wire format).
864
+ * @return {!Uint8Array}
865
+ */
866
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.serializeBinary = function() {
867
+ var writer = new jspb.BinaryWriter();
868
+ proto.engine_api.EnclaveAPIContainerInfo.serializeBinaryToWriter(this, writer);
869
+ return writer.getResultBuffer();
870
+ };
871
+
872
+
873
+ /**
874
+ * Serializes the given message to binary data (in protobuf wire
875
+ * format), writing to the given BinaryWriter.
876
+ * @param {!proto.engine_api.EnclaveAPIContainerInfo} message
877
+ * @param {!jspb.BinaryWriter} writer
878
+ * @suppress {unusedLocalVariables} f is only used for nested messages
879
+ */
880
+ proto.engine_api.EnclaveAPIContainerInfo.serializeBinaryToWriter = function(message, writer) {
881
+ var f = undefined;
882
+ f = message.getContainerId();
883
+ if (f.length > 0) {
884
+ writer.writeString(
885
+ 1,
886
+ f
887
+ );
888
+ }
889
+ f = message.getIpInsideEnclave();
890
+ if (f.length > 0) {
891
+ writer.writeString(
892
+ 2,
893
+ f
894
+ );
895
+ }
896
+ f = message.getGrpcPortInsideEnclave();
897
+ if (f !== 0) {
898
+ writer.writeUint32(
899
+ 3,
900
+ f
901
+ );
902
+ }
903
+ f = message.getGrpcProxyPortInsideEnclave();
904
+ if (f !== 0) {
905
+ writer.writeUint32(
906
+ 4,
907
+ f
908
+ );
909
+ }
910
+ };
911
+
912
+
913
+ /**
914
+ * optional string container_id = 1;
915
+ * @return {string}
916
+ */
917
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.getContainerId = function() {
918
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
919
+ };
920
+
921
+
922
+ /**
923
+ * @param {string} value
924
+ * @return {!proto.engine_api.EnclaveAPIContainerInfo} returns this
925
+ */
926
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.setContainerId = function(value) {
927
+ return jspb.Message.setProto3StringField(this, 1, value);
928
+ };
929
+
930
+
931
+ /**
932
+ * optional string ip_inside_enclave = 2;
933
+ * @return {string}
934
+ */
935
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.getIpInsideEnclave = function() {
936
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
937
+ };
938
+
939
+
940
+ /**
941
+ * @param {string} value
942
+ * @return {!proto.engine_api.EnclaveAPIContainerInfo} returns this
943
+ */
944
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.setIpInsideEnclave = function(value) {
945
+ return jspb.Message.setProto3StringField(this, 2, value);
946
+ };
947
+
948
+
949
+ /**
950
+ * optional uint32 grpc_port_inside_enclave = 3;
951
+ * @return {number}
952
+ */
953
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.getGrpcPortInsideEnclave = function() {
954
+ return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
955
+ };
956
+
957
+
958
+ /**
959
+ * @param {number} value
960
+ * @return {!proto.engine_api.EnclaveAPIContainerInfo} returns this
961
+ */
962
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.setGrpcPortInsideEnclave = function(value) {
963
+ return jspb.Message.setProto3IntField(this, 3, value);
964
+ };
965
+
966
+
967
+ /**
968
+ * optional uint32 grpc_proxy_port_inside_enclave = 4;
969
+ * @return {number}
970
+ */
971
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.getGrpcProxyPortInsideEnclave = function() {
972
+ return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
973
+ };
974
+
975
+
976
+ /**
977
+ * @param {number} value
978
+ * @return {!proto.engine_api.EnclaveAPIContainerInfo} returns this
979
+ */
980
+ proto.engine_api.EnclaveAPIContainerInfo.prototype.setGrpcProxyPortInsideEnclave = function(value) {
981
+ return jspb.Message.setProto3IntField(this, 4, value);
982
+ };
983
+
984
+
985
+
986
+
987
+
988
+ if (jspb.Message.GENERATE_TO_OBJECT) {
989
+ /**
990
+ * Creates an object representation of this proto.
991
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
992
+ * Optional fields that are not set will be set to undefined.
993
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
994
+ * For the list of reserved names please see:
995
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
996
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
997
+ * JSPB instance for transitional soy proto support:
998
+ * http://goto/soy-param-migration
999
+ * @return {!Object}
1000
+ */
1001
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.toObject = function(opt_includeInstance) {
1002
+ return proto.engine_api.EnclaveAPIContainerHostMachineInfo.toObject(opt_includeInstance, this);
1003
+ };
1004
+
1005
+
1006
+ /**
1007
+ * Static version of the {@see toObject} method.
1008
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
1009
+ * the JSPB instance for transitional soy proto support:
1010
+ * http://goto/soy-param-migration
1011
+ * @param {!proto.engine_api.EnclaveAPIContainerHostMachineInfo} msg The msg instance to transform.
1012
+ * @return {!Object}
1013
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1014
+ */
1015
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.toObject = function(includeInstance, msg) {
1016
+ var f, obj = {
1017
+ ipOnHostMachine: jspb.Message.getFieldWithDefault(msg, 4, ""),
1018
+ grpcPortOnHostMachine: jspb.Message.getFieldWithDefault(msg, 5, 0),
1019
+ grpcProxyPortOnHostMachine: jspb.Message.getFieldWithDefault(msg, 6, 0)
1020
+ };
1021
+
1022
+ if (includeInstance) {
1023
+ obj.$jspbMessageInstance = msg;
1024
+ }
1025
+ return obj;
1026
+ };
1027
+ }
1028
+
1029
+
1030
+ /**
1031
+ * Deserializes binary data (in protobuf wire format).
1032
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
1033
+ * @return {!proto.engine_api.EnclaveAPIContainerHostMachineInfo}
1034
+ */
1035
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.deserializeBinary = function(bytes) {
1036
+ var reader = new jspb.BinaryReader(bytes);
1037
+ var msg = new proto.engine_api.EnclaveAPIContainerHostMachineInfo;
1038
+ return proto.engine_api.EnclaveAPIContainerHostMachineInfo.deserializeBinaryFromReader(msg, reader);
1039
+ };
1040
+
1041
+
1042
+ /**
1043
+ * Deserializes binary data (in protobuf wire format) from the
1044
+ * given reader into the given message object.
1045
+ * @param {!proto.engine_api.EnclaveAPIContainerHostMachineInfo} msg The message object to deserialize into.
1046
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
1047
+ * @return {!proto.engine_api.EnclaveAPIContainerHostMachineInfo}
1048
+ */
1049
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.deserializeBinaryFromReader = function(msg, reader) {
1050
+ while (reader.nextField()) {
1051
+ if (reader.isEndGroup()) {
1052
+ break;
1053
+ }
1054
+ var field = reader.getFieldNumber();
1055
+ switch (field) {
1056
+ case 4:
1057
+ var value = /** @type {string} */ (reader.readString());
1058
+ msg.setIpOnHostMachine(value);
1059
+ break;
1060
+ case 5:
1061
+ var value = /** @type {number} */ (reader.readUint32());
1062
+ msg.setGrpcPortOnHostMachine(value);
1063
+ break;
1064
+ case 6:
1065
+ var value = /** @type {number} */ (reader.readUint32());
1066
+ msg.setGrpcProxyPortOnHostMachine(value);
1067
+ break;
1068
+ default:
1069
+ reader.skipField();
1070
+ break;
1071
+ }
1072
+ }
1073
+ return msg;
1074
+ };
1075
+
1076
+
1077
+ /**
1078
+ * Serializes the message to binary data (in protobuf wire format).
1079
+ * @return {!Uint8Array}
1080
+ */
1081
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.serializeBinary = function() {
1082
+ var writer = new jspb.BinaryWriter();
1083
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.serializeBinaryToWriter(this, writer);
1084
+ return writer.getResultBuffer();
1085
+ };
1086
+
1087
+
1088
+ /**
1089
+ * Serializes the given message to binary data (in protobuf wire
1090
+ * format), writing to the given BinaryWriter.
1091
+ * @param {!proto.engine_api.EnclaveAPIContainerHostMachineInfo} message
1092
+ * @param {!jspb.BinaryWriter} writer
1093
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1094
+ */
1095
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.serializeBinaryToWriter = function(message, writer) {
1096
+ var f = undefined;
1097
+ f = message.getIpOnHostMachine();
1098
+ if (f.length > 0) {
1099
+ writer.writeString(
1100
+ 4,
1101
+ f
1102
+ );
1103
+ }
1104
+ f = message.getGrpcPortOnHostMachine();
1105
+ if (f !== 0) {
1106
+ writer.writeUint32(
1107
+ 5,
1108
+ f
1109
+ );
1110
+ }
1111
+ f = message.getGrpcProxyPortOnHostMachine();
1112
+ if (f !== 0) {
1113
+ writer.writeUint32(
1114
+ 6,
1115
+ f
1116
+ );
1117
+ }
1118
+ };
1119
+
1120
+
1121
+ /**
1122
+ * optional string ip_on_host_machine = 4;
1123
+ * @return {string}
1124
+ */
1125
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.getIpOnHostMachine = function() {
1126
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 4, ""));
1127
+ };
1128
+
1129
+
1130
+ /**
1131
+ * @param {string} value
1132
+ * @return {!proto.engine_api.EnclaveAPIContainerHostMachineInfo} returns this
1133
+ */
1134
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.setIpOnHostMachine = function(value) {
1135
+ return jspb.Message.setProto3StringField(this, 4, value);
1136
+ };
1137
+
1138
+
1139
+ /**
1140
+ * optional uint32 grpc_port_on_host_machine = 5;
1141
+ * @return {number}
1142
+ */
1143
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.getGrpcPortOnHostMachine = function() {
1144
+ return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 5, 0));
1145
+ };
1146
+
1147
+
1148
+ /**
1149
+ * @param {number} value
1150
+ * @return {!proto.engine_api.EnclaveAPIContainerHostMachineInfo} returns this
1151
+ */
1152
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.setGrpcPortOnHostMachine = function(value) {
1153
+ return jspb.Message.setProto3IntField(this, 5, value);
1154
+ };
1155
+
1156
+
1157
+ /**
1158
+ * optional uint32 grpc_proxy_port_on_host_machine = 6;
1159
+ * @return {number}
1160
+ */
1161
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.getGrpcProxyPortOnHostMachine = function() {
1162
+ return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 6, 0));
1163
+ };
1164
+
1165
+
1166
+ /**
1167
+ * @param {number} value
1168
+ * @return {!proto.engine_api.EnclaveAPIContainerHostMachineInfo} returns this
1169
+ */
1170
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.prototype.setGrpcProxyPortOnHostMachine = function(value) {
1171
+ return jspb.Message.setProto3IntField(this, 6, value);
1172
+ };
1173
+
1174
+
1175
+
1176
+
1177
+
1178
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1179
+ /**
1180
+ * Creates an object representation of this proto.
1181
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
1182
+ * Optional fields that are not set will be set to undefined.
1183
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
1184
+ * For the list of reserved names please see:
1185
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
1186
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
1187
+ * JSPB instance for transitional soy proto support:
1188
+ * http://goto/soy-param-migration
1189
+ * @return {!Object}
1190
+ */
1191
+ proto.engine_api.EnclaveInfo.prototype.toObject = function(opt_includeInstance) {
1192
+ return proto.engine_api.EnclaveInfo.toObject(opt_includeInstance, this);
1193
+ };
1194
+
1195
+
1196
+ /**
1197
+ * Static version of the {@see toObject} method.
1198
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
1199
+ * the JSPB instance for transitional soy proto support:
1200
+ * http://goto/soy-param-migration
1201
+ * @param {!proto.engine_api.EnclaveInfo} msg The msg instance to transform.
1202
+ * @return {!Object}
1203
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1204
+ */
1205
+ proto.engine_api.EnclaveInfo.toObject = function(includeInstance, msg) {
1206
+ var f, obj = {
1207
+ enclaveId: jspb.Message.getFieldWithDefault(msg, 1, ""),
1208
+ containersStatus: jspb.Message.getFieldWithDefault(msg, 2, 0),
1209
+ apiContainerStatus: jspb.Message.getFieldWithDefault(msg, 3, 0),
1210
+ apiContainerInfo: (f = msg.getApiContainerInfo()) && proto.engine_api.EnclaveAPIContainerInfo.toObject(includeInstance, f),
1211
+ apiContainerHostMachineInfo: (f = msg.getApiContainerHostMachineInfo()) && proto.engine_api.EnclaveAPIContainerHostMachineInfo.toObject(includeInstance, f)
1212
+ };
1213
+
1214
+ if (includeInstance) {
1215
+ obj.$jspbMessageInstance = msg;
1216
+ }
1217
+ return obj;
1218
+ };
1219
+ }
1220
+
1221
+
1222
+ /**
1223
+ * Deserializes binary data (in protobuf wire format).
1224
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
1225
+ * @return {!proto.engine_api.EnclaveInfo}
1226
+ */
1227
+ proto.engine_api.EnclaveInfo.deserializeBinary = function(bytes) {
1228
+ var reader = new jspb.BinaryReader(bytes);
1229
+ var msg = new proto.engine_api.EnclaveInfo;
1230
+ return proto.engine_api.EnclaveInfo.deserializeBinaryFromReader(msg, reader);
1231
+ };
1232
+
1233
+
1234
+ /**
1235
+ * Deserializes binary data (in protobuf wire format) from the
1236
+ * given reader into the given message object.
1237
+ * @param {!proto.engine_api.EnclaveInfo} msg The message object to deserialize into.
1238
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
1239
+ * @return {!proto.engine_api.EnclaveInfo}
1240
+ */
1241
+ proto.engine_api.EnclaveInfo.deserializeBinaryFromReader = function(msg, reader) {
1242
+ while (reader.nextField()) {
1243
+ if (reader.isEndGroup()) {
1244
+ break;
1245
+ }
1246
+ var field = reader.getFieldNumber();
1247
+ switch (field) {
1248
+ case 1:
1249
+ var value = /** @type {string} */ (reader.readString());
1250
+ msg.setEnclaveId(value);
1251
+ break;
1252
+ case 2:
1253
+ var value = /** @type {!proto.engine_api.EnclaveContainersStatus} */ (reader.readEnum());
1254
+ msg.setContainersStatus(value);
1255
+ break;
1256
+ case 3:
1257
+ var value = /** @type {!proto.engine_api.EnclaveAPIContainerStatus} */ (reader.readEnum());
1258
+ msg.setApiContainerStatus(value);
1259
+ break;
1260
+ case 4:
1261
+ var value = new proto.engine_api.EnclaveAPIContainerInfo;
1262
+ reader.readMessage(value,proto.engine_api.EnclaveAPIContainerInfo.deserializeBinaryFromReader);
1263
+ msg.setApiContainerInfo(value);
1264
+ break;
1265
+ case 5:
1266
+ var value = new proto.engine_api.EnclaveAPIContainerHostMachineInfo;
1267
+ reader.readMessage(value,proto.engine_api.EnclaveAPIContainerHostMachineInfo.deserializeBinaryFromReader);
1268
+ msg.setApiContainerHostMachineInfo(value);
1269
+ break;
1270
+ default:
1271
+ reader.skipField();
1272
+ break;
1273
+ }
1274
+ }
1275
+ return msg;
1276
+ };
1277
+
1278
+
1279
+ /**
1280
+ * Serializes the message to binary data (in protobuf wire format).
1281
+ * @return {!Uint8Array}
1282
+ */
1283
+ proto.engine_api.EnclaveInfo.prototype.serializeBinary = function() {
1284
+ var writer = new jspb.BinaryWriter();
1285
+ proto.engine_api.EnclaveInfo.serializeBinaryToWriter(this, writer);
1286
+ return writer.getResultBuffer();
1287
+ };
1288
+
1289
+
1290
+ /**
1291
+ * Serializes the given message to binary data (in protobuf wire
1292
+ * format), writing to the given BinaryWriter.
1293
+ * @param {!proto.engine_api.EnclaveInfo} message
1294
+ * @param {!jspb.BinaryWriter} writer
1295
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1296
+ */
1297
+ proto.engine_api.EnclaveInfo.serializeBinaryToWriter = function(message, writer) {
1298
+ var f = undefined;
1299
+ f = message.getEnclaveId();
1300
+ if (f.length > 0) {
1301
+ writer.writeString(
1302
+ 1,
1303
+ f
1304
+ );
1305
+ }
1306
+ f = message.getContainersStatus();
1307
+ if (f !== 0.0) {
1308
+ writer.writeEnum(
1309
+ 2,
1310
+ f
1311
+ );
1312
+ }
1313
+ f = message.getApiContainerStatus();
1314
+ if (f !== 0.0) {
1315
+ writer.writeEnum(
1316
+ 3,
1317
+ f
1318
+ );
1319
+ }
1320
+ f = message.getApiContainerInfo();
1321
+ if (f != null) {
1322
+ writer.writeMessage(
1323
+ 4,
1324
+ f,
1325
+ proto.engine_api.EnclaveAPIContainerInfo.serializeBinaryToWriter
1326
+ );
1327
+ }
1328
+ f = message.getApiContainerHostMachineInfo();
1329
+ if (f != null) {
1330
+ writer.writeMessage(
1331
+ 5,
1332
+ f,
1333
+ proto.engine_api.EnclaveAPIContainerHostMachineInfo.serializeBinaryToWriter
1334
+ );
1335
+ }
1336
+ };
1337
+
1338
+
1339
+ /**
1340
+ * optional string enclave_id = 1;
1341
+ * @return {string}
1342
+ */
1343
+ proto.engine_api.EnclaveInfo.prototype.getEnclaveId = function() {
1344
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
1345
+ };
1346
+
1347
+
1348
+ /**
1349
+ * @param {string} value
1350
+ * @return {!proto.engine_api.EnclaveInfo} returns this
1351
+ */
1352
+ proto.engine_api.EnclaveInfo.prototype.setEnclaveId = function(value) {
1353
+ return jspb.Message.setProto3StringField(this, 1, value);
1354
+ };
1355
+
1356
+
1357
+ /**
1358
+ * optional EnclaveContainersStatus containers_status = 2;
1359
+ * @return {!proto.engine_api.EnclaveContainersStatus}
1360
+ */
1361
+ proto.engine_api.EnclaveInfo.prototype.getContainersStatus = function() {
1362
+ return /** @type {!proto.engine_api.EnclaveContainersStatus} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
1363
+ };
1364
+
1365
+
1366
+ /**
1367
+ * @param {!proto.engine_api.EnclaveContainersStatus} value
1368
+ * @return {!proto.engine_api.EnclaveInfo} returns this
1369
+ */
1370
+ proto.engine_api.EnclaveInfo.prototype.setContainersStatus = function(value) {
1371
+ return jspb.Message.setProto3EnumField(this, 2, value);
1372
+ };
1373
+
1374
+
1375
+ /**
1376
+ * optional EnclaveAPIContainerStatus api_container_status = 3;
1377
+ * @return {!proto.engine_api.EnclaveAPIContainerStatus}
1378
+ */
1379
+ proto.engine_api.EnclaveInfo.prototype.getApiContainerStatus = function() {
1380
+ return /** @type {!proto.engine_api.EnclaveAPIContainerStatus} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
1381
+ };
1382
+
1383
+
1384
+ /**
1385
+ * @param {!proto.engine_api.EnclaveAPIContainerStatus} value
1386
+ * @return {!proto.engine_api.EnclaveInfo} returns this
1387
+ */
1388
+ proto.engine_api.EnclaveInfo.prototype.setApiContainerStatus = function(value) {
1389
+ return jspb.Message.setProto3EnumField(this, 3, value);
1390
+ };
1391
+
1392
+
1393
+ /**
1394
+ * optional EnclaveAPIContainerInfo api_container_info = 4;
1395
+ * @return {?proto.engine_api.EnclaveAPIContainerInfo}
1396
+ */
1397
+ proto.engine_api.EnclaveInfo.prototype.getApiContainerInfo = function() {
1398
+ return /** @type{?proto.engine_api.EnclaveAPIContainerInfo} */ (
1399
+ jspb.Message.getWrapperField(this, proto.engine_api.EnclaveAPIContainerInfo, 4));
1400
+ };
1401
+
1402
+
1403
+ /**
1404
+ * @param {?proto.engine_api.EnclaveAPIContainerInfo|undefined} value
1405
+ * @return {!proto.engine_api.EnclaveInfo} returns this
1406
+ */
1407
+ proto.engine_api.EnclaveInfo.prototype.setApiContainerInfo = function(value) {
1408
+ return jspb.Message.setWrapperField(this, 4, value);
1409
+ };
1410
+
1411
+
1412
+ /**
1413
+ * Clears the message field making it undefined.
1414
+ * @return {!proto.engine_api.EnclaveInfo} returns this
1415
+ */
1416
+ proto.engine_api.EnclaveInfo.prototype.clearApiContainerInfo = function() {
1417
+ return this.setApiContainerInfo(undefined);
1418
+ };
1419
+
1420
+
1421
+ /**
1422
+ * Returns whether this field is set.
1423
+ * @return {boolean}
1424
+ */
1425
+ proto.engine_api.EnclaveInfo.prototype.hasApiContainerInfo = function() {
1426
+ return jspb.Message.getField(this, 4) != null;
1427
+ };
1428
+
1429
+
1430
+ /**
1431
+ * optional EnclaveAPIContainerHostMachineInfo api_container_host_machine_info = 5;
1432
+ * @return {?proto.engine_api.EnclaveAPIContainerHostMachineInfo}
1433
+ */
1434
+ proto.engine_api.EnclaveInfo.prototype.getApiContainerHostMachineInfo = function() {
1435
+ return /** @type{?proto.engine_api.EnclaveAPIContainerHostMachineInfo} */ (
1436
+ jspb.Message.getWrapperField(this, proto.engine_api.EnclaveAPIContainerHostMachineInfo, 5));
1437
+ };
1438
+
1439
+
1440
+ /**
1441
+ * @param {?proto.engine_api.EnclaveAPIContainerHostMachineInfo|undefined} value
1442
+ * @return {!proto.engine_api.EnclaveInfo} returns this
1443
+ */
1444
+ proto.engine_api.EnclaveInfo.prototype.setApiContainerHostMachineInfo = function(value) {
1445
+ return jspb.Message.setWrapperField(this, 5, value);
1446
+ };
1447
+
1448
+
1449
+ /**
1450
+ * Clears the message field making it undefined.
1451
+ * @return {!proto.engine_api.EnclaveInfo} returns this
1452
+ */
1453
+ proto.engine_api.EnclaveInfo.prototype.clearApiContainerHostMachineInfo = function() {
1454
+ return this.setApiContainerHostMachineInfo(undefined);
1455
+ };
1456
+
1457
+
1458
+ /**
1459
+ * Returns whether this field is set.
1460
+ * @return {boolean}
1461
+ */
1462
+ proto.engine_api.EnclaveInfo.prototype.hasApiContainerHostMachineInfo = function() {
1463
+ return jspb.Message.getField(this, 5) != null;
1464
+ };
1465
+
1466
+
1467
+
1468
+
1469
+
1470
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1471
+ /**
1472
+ * Creates an object representation of this proto.
1473
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
1474
+ * Optional fields that are not set will be set to undefined.
1475
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
1476
+ * For the list of reserved names please see:
1477
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
1478
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
1479
+ * JSPB instance for transitional soy proto support:
1480
+ * http://goto/soy-param-migration
1481
+ * @return {!Object}
1482
+ */
1483
+ proto.engine_api.GetEnclavesResponse.prototype.toObject = function(opt_includeInstance) {
1484
+ return proto.engine_api.GetEnclavesResponse.toObject(opt_includeInstance, this);
1485
+ };
1486
+
1487
+
1488
+ /**
1489
+ * Static version of the {@see toObject} method.
1490
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
1491
+ * the JSPB instance for transitional soy proto support:
1492
+ * http://goto/soy-param-migration
1493
+ * @param {!proto.engine_api.GetEnclavesResponse} msg The msg instance to transform.
1494
+ * @return {!Object}
1495
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1496
+ */
1497
+ proto.engine_api.GetEnclavesResponse.toObject = function(includeInstance, msg) {
1498
+ var f, obj = {
1499
+ enclaveInfoMap: (f = msg.getEnclaveInfoMap()) ? f.toObject(includeInstance, proto.engine_api.EnclaveInfo.toObject) : []
1500
+ };
1501
+
1502
+ if (includeInstance) {
1503
+ obj.$jspbMessageInstance = msg;
1504
+ }
1505
+ return obj;
1506
+ };
1507
+ }
1508
+
1509
+
1510
+ /**
1511
+ * Deserializes binary data (in protobuf wire format).
1512
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
1513
+ * @return {!proto.engine_api.GetEnclavesResponse}
1514
+ */
1515
+ proto.engine_api.GetEnclavesResponse.deserializeBinary = function(bytes) {
1516
+ var reader = new jspb.BinaryReader(bytes);
1517
+ var msg = new proto.engine_api.GetEnclavesResponse;
1518
+ return proto.engine_api.GetEnclavesResponse.deserializeBinaryFromReader(msg, reader);
1519
+ };
1520
+
1521
+
1522
+ /**
1523
+ * Deserializes binary data (in protobuf wire format) from the
1524
+ * given reader into the given message object.
1525
+ * @param {!proto.engine_api.GetEnclavesResponse} msg The message object to deserialize into.
1526
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
1527
+ * @return {!proto.engine_api.GetEnclavesResponse}
1528
+ */
1529
+ proto.engine_api.GetEnclavesResponse.deserializeBinaryFromReader = function(msg, reader) {
1530
+ while (reader.nextField()) {
1531
+ if (reader.isEndGroup()) {
1532
+ break;
1533
+ }
1534
+ var field = reader.getFieldNumber();
1535
+ switch (field) {
1536
+ case 1:
1537
+ var value = msg.getEnclaveInfoMap();
1538
+ reader.readMessage(value, function(message, reader) {
1539
+ jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readMessage, proto.engine_api.EnclaveInfo.deserializeBinaryFromReader, "", new proto.engine_api.EnclaveInfo());
1540
+ });
1541
+ break;
1542
+ default:
1543
+ reader.skipField();
1544
+ break;
1545
+ }
1546
+ }
1547
+ return msg;
1548
+ };
1549
+
1550
+
1551
+ /**
1552
+ * Serializes the message to binary data (in protobuf wire format).
1553
+ * @return {!Uint8Array}
1554
+ */
1555
+ proto.engine_api.GetEnclavesResponse.prototype.serializeBinary = function() {
1556
+ var writer = new jspb.BinaryWriter();
1557
+ proto.engine_api.GetEnclavesResponse.serializeBinaryToWriter(this, writer);
1558
+ return writer.getResultBuffer();
1559
+ };
1560
+
1561
+
1562
+ /**
1563
+ * Serializes the given message to binary data (in protobuf wire
1564
+ * format), writing to the given BinaryWriter.
1565
+ * @param {!proto.engine_api.GetEnclavesResponse} message
1566
+ * @param {!jspb.BinaryWriter} writer
1567
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1568
+ */
1569
+ proto.engine_api.GetEnclavesResponse.serializeBinaryToWriter = function(message, writer) {
1570
+ var f = undefined;
1571
+ f = message.getEnclaveInfoMap(true);
1572
+ if (f && f.getLength() > 0) {
1573
+ f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeMessage, proto.engine_api.EnclaveInfo.serializeBinaryToWriter);
1574
+ }
1575
+ };
1576
+
1577
+
1578
+ /**
1579
+ * map<string, EnclaveInfo> enclave_info = 1;
1580
+ * @param {boolean=} opt_noLazyCreate Do not create the map if
1581
+ * empty, instead returning `undefined`
1582
+ * @return {!jspb.Map<string,!proto.engine_api.EnclaveInfo>}
1583
+ */
1584
+ proto.engine_api.GetEnclavesResponse.prototype.getEnclaveInfoMap = function(opt_noLazyCreate) {
1585
+ return /** @type {!jspb.Map<string,!proto.engine_api.EnclaveInfo>} */ (
1586
+ jspb.Message.getMapField(this, 1, opt_noLazyCreate,
1587
+ proto.engine_api.EnclaveInfo));
1588
+ };
1589
+
1590
+
1591
+ /**
1592
+ * Clears values from the map. The map will be non-null.
1593
+ * @return {!proto.engine_api.GetEnclavesResponse} returns this
1594
+ */
1595
+ proto.engine_api.GetEnclavesResponse.prototype.clearEnclaveInfoMap = function() {
1596
+ this.getEnclaveInfoMap().clear();
1597
+ return this;};
1598
+
1599
+
1600
+
1601
+
1602
+
1603
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1604
+ /**
1605
+ * Creates an object representation of this proto.
1606
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
1607
+ * Optional fields that are not set will be set to undefined.
1608
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
1609
+ * For the list of reserved names please see:
1610
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
1611
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
1612
+ * JSPB instance for transitional soy proto support:
1613
+ * http://goto/soy-param-migration
1614
+ * @return {!Object}
1615
+ */
1616
+ proto.engine_api.StopEnclaveArgs.prototype.toObject = function(opt_includeInstance) {
1617
+ return proto.engine_api.StopEnclaveArgs.toObject(opt_includeInstance, this);
1618
+ };
1619
+
1620
+
1621
+ /**
1622
+ * Static version of the {@see toObject} method.
1623
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
1624
+ * the JSPB instance for transitional soy proto support:
1625
+ * http://goto/soy-param-migration
1626
+ * @param {!proto.engine_api.StopEnclaveArgs} msg The msg instance to transform.
1627
+ * @return {!Object}
1628
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1629
+ */
1630
+ proto.engine_api.StopEnclaveArgs.toObject = function(includeInstance, msg) {
1631
+ var f, obj = {
1632
+ enclaveId: jspb.Message.getFieldWithDefault(msg, 1, "")
1633
+ };
1634
+
1635
+ if (includeInstance) {
1636
+ obj.$jspbMessageInstance = msg;
1637
+ }
1638
+ return obj;
1639
+ };
1640
+ }
1641
+
1642
+
1643
+ /**
1644
+ * Deserializes binary data (in protobuf wire format).
1645
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
1646
+ * @return {!proto.engine_api.StopEnclaveArgs}
1647
+ */
1648
+ proto.engine_api.StopEnclaveArgs.deserializeBinary = function(bytes) {
1649
+ var reader = new jspb.BinaryReader(bytes);
1650
+ var msg = new proto.engine_api.StopEnclaveArgs;
1651
+ return proto.engine_api.StopEnclaveArgs.deserializeBinaryFromReader(msg, reader);
1652
+ };
1653
+
1654
+
1655
+ /**
1656
+ * Deserializes binary data (in protobuf wire format) from the
1657
+ * given reader into the given message object.
1658
+ * @param {!proto.engine_api.StopEnclaveArgs} msg The message object to deserialize into.
1659
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
1660
+ * @return {!proto.engine_api.StopEnclaveArgs}
1661
+ */
1662
+ proto.engine_api.StopEnclaveArgs.deserializeBinaryFromReader = function(msg, reader) {
1663
+ while (reader.nextField()) {
1664
+ if (reader.isEndGroup()) {
1665
+ break;
1666
+ }
1667
+ var field = reader.getFieldNumber();
1668
+ switch (field) {
1669
+ case 1:
1670
+ var value = /** @type {string} */ (reader.readString());
1671
+ msg.setEnclaveId(value);
1672
+ break;
1673
+ default:
1674
+ reader.skipField();
1675
+ break;
1676
+ }
1677
+ }
1678
+ return msg;
1679
+ };
1680
+
1681
+
1682
+ /**
1683
+ * Serializes the message to binary data (in protobuf wire format).
1684
+ * @return {!Uint8Array}
1685
+ */
1686
+ proto.engine_api.StopEnclaveArgs.prototype.serializeBinary = function() {
1687
+ var writer = new jspb.BinaryWriter();
1688
+ proto.engine_api.StopEnclaveArgs.serializeBinaryToWriter(this, writer);
1689
+ return writer.getResultBuffer();
1690
+ };
1691
+
1692
+
1693
+ /**
1694
+ * Serializes the given message to binary data (in protobuf wire
1695
+ * format), writing to the given BinaryWriter.
1696
+ * @param {!proto.engine_api.StopEnclaveArgs} message
1697
+ * @param {!jspb.BinaryWriter} writer
1698
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1699
+ */
1700
+ proto.engine_api.StopEnclaveArgs.serializeBinaryToWriter = function(message, writer) {
1701
+ var f = undefined;
1702
+ f = message.getEnclaveId();
1703
+ if (f.length > 0) {
1704
+ writer.writeString(
1705
+ 1,
1706
+ f
1707
+ );
1708
+ }
1709
+ };
1710
+
1711
+
1712
+ /**
1713
+ * optional string enclave_id = 1;
1714
+ * @return {string}
1715
+ */
1716
+ proto.engine_api.StopEnclaveArgs.prototype.getEnclaveId = function() {
1717
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
1718
+ };
1719
+
1720
+
1721
+ /**
1722
+ * @param {string} value
1723
+ * @return {!proto.engine_api.StopEnclaveArgs} returns this
1724
+ */
1725
+ proto.engine_api.StopEnclaveArgs.prototype.setEnclaveId = function(value) {
1726
+ return jspb.Message.setProto3StringField(this, 1, value);
1727
+ };
1728
+
1729
+
1730
+
1731
+
1732
+
1733
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1734
+ /**
1735
+ * Creates an object representation of this proto.
1736
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
1737
+ * Optional fields that are not set will be set to undefined.
1738
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
1739
+ * For the list of reserved names please see:
1740
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
1741
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
1742
+ * JSPB instance for transitional soy proto support:
1743
+ * http://goto/soy-param-migration
1744
+ * @return {!Object}
1745
+ */
1746
+ proto.engine_api.DestroyEnclaveArgs.prototype.toObject = function(opt_includeInstance) {
1747
+ return proto.engine_api.DestroyEnclaveArgs.toObject(opt_includeInstance, this);
1748
+ };
1749
+
1750
+
1751
+ /**
1752
+ * Static version of the {@see toObject} method.
1753
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
1754
+ * the JSPB instance for transitional soy proto support:
1755
+ * http://goto/soy-param-migration
1756
+ * @param {!proto.engine_api.DestroyEnclaveArgs} msg The msg instance to transform.
1757
+ * @return {!Object}
1758
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1759
+ */
1760
+ proto.engine_api.DestroyEnclaveArgs.toObject = function(includeInstance, msg) {
1761
+ var f, obj = {
1762
+ enclaveId: jspb.Message.getFieldWithDefault(msg, 1, "")
1763
+ };
1764
+
1765
+ if (includeInstance) {
1766
+ obj.$jspbMessageInstance = msg;
1767
+ }
1768
+ return obj;
1769
+ };
1770
+ }
1771
+
1772
+
1773
+ /**
1774
+ * Deserializes binary data (in protobuf wire format).
1775
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
1776
+ * @return {!proto.engine_api.DestroyEnclaveArgs}
1777
+ */
1778
+ proto.engine_api.DestroyEnclaveArgs.deserializeBinary = function(bytes) {
1779
+ var reader = new jspb.BinaryReader(bytes);
1780
+ var msg = new proto.engine_api.DestroyEnclaveArgs;
1781
+ return proto.engine_api.DestroyEnclaveArgs.deserializeBinaryFromReader(msg, reader);
1782
+ };
1783
+
1784
+
1785
+ /**
1786
+ * Deserializes binary data (in protobuf wire format) from the
1787
+ * given reader into the given message object.
1788
+ * @param {!proto.engine_api.DestroyEnclaveArgs} msg The message object to deserialize into.
1789
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
1790
+ * @return {!proto.engine_api.DestroyEnclaveArgs}
1791
+ */
1792
+ proto.engine_api.DestroyEnclaveArgs.deserializeBinaryFromReader = function(msg, reader) {
1793
+ while (reader.nextField()) {
1794
+ if (reader.isEndGroup()) {
1795
+ break;
1796
+ }
1797
+ var field = reader.getFieldNumber();
1798
+ switch (field) {
1799
+ case 1:
1800
+ var value = /** @type {string} */ (reader.readString());
1801
+ msg.setEnclaveId(value);
1802
+ break;
1803
+ default:
1804
+ reader.skipField();
1805
+ break;
1806
+ }
1807
+ }
1808
+ return msg;
1809
+ };
1810
+
1811
+
1812
+ /**
1813
+ * Serializes the message to binary data (in protobuf wire format).
1814
+ * @return {!Uint8Array}
1815
+ */
1816
+ proto.engine_api.DestroyEnclaveArgs.prototype.serializeBinary = function() {
1817
+ var writer = new jspb.BinaryWriter();
1818
+ proto.engine_api.DestroyEnclaveArgs.serializeBinaryToWriter(this, writer);
1819
+ return writer.getResultBuffer();
1820
+ };
1821
+
1822
+
1823
+ /**
1824
+ * Serializes the given message to binary data (in protobuf wire
1825
+ * format), writing to the given BinaryWriter.
1826
+ * @param {!proto.engine_api.DestroyEnclaveArgs} message
1827
+ * @param {!jspb.BinaryWriter} writer
1828
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1829
+ */
1830
+ proto.engine_api.DestroyEnclaveArgs.serializeBinaryToWriter = function(message, writer) {
1831
+ var f = undefined;
1832
+ f = message.getEnclaveId();
1833
+ if (f.length > 0) {
1834
+ writer.writeString(
1835
+ 1,
1836
+ f
1837
+ );
1838
+ }
1839
+ };
1840
+
1841
+
1842
+ /**
1843
+ * optional string enclave_id = 1;
1844
+ * @return {string}
1845
+ */
1846
+ proto.engine_api.DestroyEnclaveArgs.prototype.getEnclaveId = function() {
1847
+ return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
1848
+ };
1849
+
1850
+
1851
+ /**
1852
+ * @param {string} value
1853
+ * @return {!proto.engine_api.DestroyEnclaveArgs} returns this
1854
+ */
1855
+ proto.engine_api.DestroyEnclaveArgs.prototype.setEnclaveId = function(value) {
1856
+ return jspb.Message.setProto3StringField(this, 1, value);
1857
+ };
1858
+
1859
+
1860
+
1861
+
1862
+
1863
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1864
+ /**
1865
+ * Creates an object representation of this proto.
1866
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
1867
+ * Optional fields that are not set will be set to undefined.
1868
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
1869
+ * For the list of reserved names please see:
1870
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
1871
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
1872
+ * JSPB instance for transitional soy proto support:
1873
+ * http://goto/soy-param-migration
1874
+ * @return {!Object}
1875
+ */
1876
+ proto.engine_api.CleanArgs.prototype.toObject = function(opt_includeInstance) {
1877
+ return proto.engine_api.CleanArgs.toObject(opt_includeInstance, this);
1878
+ };
1879
+
1880
+
1881
+ /**
1882
+ * Static version of the {@see toObject} method.
1883
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
1884
+ * the JSPB instance for transitional soy proto support:
1885
+ * http://goto/soy-param-migration
1886
+ * @param {!proto.engine_api.CleanArgs} msg The msg instance to transform.
1887
+ * @return {!Object}
1888
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1889
+ */
1890
+ proto.engine_api.CleanArgs.toObject = function(includeInstance, msg) {
1891
+ var f, obj = {
1892
+ shouldCleanAll: jspb.Message.getBooleanFieldWithDefault(msg, 1, false)
1893
+ };
1894
+
1895
+ if (includeInstance) {
1896
+ obj.$jspbMessageInstance = msg;
1897
+ }
1898
+ return obj;
1899
+ };
1900
+ }
1901
+
1902
+
1903
+ /**
1904
+ * Deserializes binary data (in protobuf wire format).
1905
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
1906
+ * @return {!proto.engine_api.CleanArgs}
1907
+ */
1908
+ proto.engine_api.CleanArgs.deserializeBinary = function(bytes) {
1909
+ var reader = new jspb.BinaryReader(bytes);
1910
+ var msg = new proto.engine_api.CleanArgs;
1911
+ return proto.engine_api.CleanArgs.deserializeBinaryFromReader(msg, reader);
1912
+ };
1913
+
1914
+
1915
+ /**
1916
+ * Deserializes binary data (in protobuf wire format) from the
1917
+ * given reader into the given message object.
1918
+ * @param {!proto.engine_api.CleanArgs} msg The message object to deserialize into.
1919
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
1920
+ * @return {!proto.engine_api.CleanArgs}
1921
+ */
1922
+ proto.engine_api.CleanArgs.deserializeBinaryFromReader = function(msg, reader) {
1923
+ while (reader.nextField()) {
1924
+ if (reader.isEndGroup()) {
1925
+ break;
1926
+ }
1927
+ var field = reader.getFieldNumber();
1928
+ switch (field) {
1929
+ case 1:
1930
+ var value = /** @type {boolean} */ (reader.readBool());
1931
+ msg.setShouldCleanAll(value);
1932
+ break;
1933
+ default:
1934
+ reader.skipField();
1935
+ break;
1936
+ }
1937
+ }
1938
+ return msg;
1939
+ };
1940
+
1941
+
1942
+ /**
1943
+ * Serializes the message to binary data (in protobuf wire format).
1944
+ * @return {!Uint8Array}
1945
+ */
1946
+ proto.engine_api.CleanArgs.prototype.serializeBinary = function() {
1947
+ var writer = new jspb.BinaryWriter();
1948
+ proto.engine_api.CleanArgs.serializeBinaryToWriter(this, writer);
1949
+ return writer.getResultBuffer();
1950
+ };
1951
+
1952
+
1953
+ /**
1954
+ * Serializes the given message to binary data (in protobuf wire
1955
+ * format), writing to the given BinaryWriter.
1956
+ * @param {!proto.engine_api.CleanArgs} message
1957
+ * @param {!jspb.BinaryWriter} writer
1958
+ * @suppress {unusedLocalVariables} f is only used for nested messages
1959
+ */
1960
+ proto.engine_api.CleanArgs.serializeBinaryToWriter = function(message, writer) {
1961
+ var f = undefined;
1962
+ f = message.getShouldCleanAll();
1963
+ if (f) {
1964
+ writer.writeBool(
1965
+ 1,
1966
+ f
1967
+ );
1968
+ }
1969
+ };
1970
+
1971
+
1972
+ /**
1973
+ * optional bool should_clean_all = 1;
1974
+ * @return {boolean}
1975
+ */
1976
+ proto.engine_api.CleanArgs.prototype.getShouldCleanAll = function() {
1977
+ return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 1, false));
1978
+ };
1979
+
1980
+
1981
+ /**
1982
+ * @param {boolean} value
1983
+ * @return {!proto.engine_api.CleanArgs} returns this
1984
+ */
1985
+ proto.engine_api.CleanArgs.prototype.setShouldCleanAll = function(value) {
1986
+ return jspb.Message.setProto3BooleanField(this, 1, value);
1987
+ };
1988
+
1989
+
1990
+
1991
+
1992
+
1993
+ if (jspb.Message.GENERATE_TO_OBJECT) {
1994
+ /**
1995
+ * Creates an object representation of this proto.
1996
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
1997
+ * Optional fields that are not set will be set to undefined.
1998
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
1999
+ * For the list of reserved names please see:
2000
+ * net/proto2/compiler/js/internal/generator.cc#kKeyword.
2001
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
2002
+ * JSPB instance for transitional soy proto support:
2003
+ * http://goto/soy-param-migration
2004
+ * @return {!Object}
2005
+ */
2006
+ proto.engine_api.CleanResponse.prototype.toObject = function(opt_includeInstance) {
2007
+ return proto.engine_api.CleanResponse.toObject(opt_includeInstance, this);
2008
+ };
2009
+
2010
+
2011
+ /**
2012
+ * Static version of the {@see toObject} method.
2013
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
2014
+ * the JSPB instance for transitional soy proto support:
2015
+ * http://goto/soy-param-migration
2016
+ * @param {!proto.engine_api.CleanResponse} msg The msg instance to transform.
2017
+ * @return {!Object}
2018
+ * @suppress {unusedLocalVariables} f is only used for nested messages
2019
+ */
2020
+ proto.engine_api.CleanResponse.toObject = function(includeInstance, msg) {
2021
+ var f, obj = {
2022
+ removedEnclaveIdsMap: (f = msg.getRemovedEnclaveIdsMap()) ? f.toObject(includeInstance, undefined) : []
2023
+ };
2024
+
2025
+ if (includeInstance) {
2026
+ obj.$jspbMessageInstance = msg;
2027
+ }
2028
+ return obj;
2029
+ };
2030
+ }
2031
+
2032
+
2033
+ /**
2034
+ * Deserializes binary data (in protobuf wire format).
2035
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
2036
+ * @return {!proto.engine_api.CleanResponse}
2037
+ */
2038
+ proto.engine_api.CleanResponse.deserializeBinary = function(bytes) {
2039
+ var reader = new jspb.BinaryReader(bytes);
2040
+ var msg = new proto.engine_api.CleanResponse;
2041
+ return proto.engine_api.CleanResponse.deserializeBinaryFromReader(msg, reader);
2042
+ };
2043
+
2044
+
2045
+ /**
2046
+ * Deserializes binary data (in protobuf wire format) from the
2047
+ * given reader into the given message object.
2048
+ * @param {!proto.engine_api.CleanResponse} msg The message object to deserialize into.
2049
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
2050
+ * @return {!proto.engine_api.CleanResponse}
2051
+ */
2052
+ proto.engine_api.CleanResponse.deserializeBinaryFromReader = function(msg, reader) {
2053
+ while (reader.nextField()) {
2054
+ if (reader.isEndGroup()) {
2055
+ break;
2056
+ }
2057
+ var field = reader.getFieldNumber();
2058
+ switch (field) {
2059
+ case 1:
2060
+ var value = msg.getRemovedEnclaveIdsMap();
2061
+ reader.readMessage(value, function(message, reader) {
2062
+ jspb.Map.deserializeBinary(message, reader, jspb.BinaryReader.prototype.readString, jspb.BinaryReader.prototype.readBool, null, "", false);
2063
+ });
2064
+ break;
2065
+ default:
2066
+ reader.skipField();
2067
+ break;
2068
+ }
2069
+ }
2070
+ return msg;
2071
+ };
2072
+
2073
+
2074
+ /**
2075
+ * Serializes the message to binary data (in protobuf wire format).
2076
+ * @return {!Uint8Array}
2077
+ */
2078
+ proto.engine_api.CleanResponse.prototype.serializeBinary = function() {
2079
+ var writer = new jspb.BinaryWriter();
2080
+ proto.engine_api.CleanResponse.serializeBinaryToWriter(this, writer);
2081
+ return writer.getResultBuffer();
2082
+ };
2083
+
2084
+
2085
+ /**
2086
+ * Serializes the given message to binary data (in protobuf wire
2087
+ * format), writing to the given BinaryWriter.
2088
+ * @param {!proto.engine_api.CleanResponse} message
2089
+ * @param {!jspb.BinaryWriter} writer
2090
+ * @suppress {unusedLocalVariables} f is only used for nested messages
2091
+ */
2092
+ proto.engine_api.CleanResponse.serializeBinaryToWriter = function(message, writer) {
2093
+ var f = undefined;
2094
+ f = message.getRemovedEnclaveIdsMap(true);
2095
+ if (f && f.getLength() > 0) {
2096
+ f.serializeBinary(1, writer, jspb.BinaryWriter.prototype.writeString, jspb.BinaryWriter.prototype.writeBool);
2097
+ }
2098
+ };
2099
+
2100
+
2101
+ /**
2102
+ * map<string, bool> removed_enclave_ids = 1;
2103
+ * @param {boolean=} opt_noLazyCreate Do not create the map if
2104
+ * empty, instead returning `undefined`
2105
+ * @return {!jspb.Map<string,boolean>}
2106
+ */
2107
+ proto.engine_api.CleanResponse.prototype.getRemovedEnclaveIdsMap = function(opt_noLazyCreate) {
2108
+ return /** @type {!jspb.Map<string,boolean>} */ (
2109
+ jspb.Message.getMapField(this, 1, opt_noLazyCreate,
2110
+ null));
2111
+ };
2112
+
2113
+
2114
+ /**
2115
+ * Clears values from the map. The map will be non-null.
2116
+ * @return {!proto.engine_api.CleanResponse} returns this
2117
+ */
2118
+ proto.engine_api.CleanResponse.prototype.clearRemovedEnclaveIdsMap = function() {
2119
+ this.getRemovedEnclaveIdsMap().clear();
2120
+ return this;};
2121
+
2122
+
2123
+ /**
2124
+ * @enum {number}
2125
+ */
2126
+ proto.engine_api.EnclaveContainersStatus = {
2127
+ ENCLAVECONTAINERSSTATUS_EMPTY: 0,
2128
+ ENCLAVECONTAINERSSTATUS_RUNNING: 1,
2129
+ ENCLAVECONTAINERSSTATUS_STOPPED: 2
2130
+ };
2131
+
2132
+ /**
2133
+ * @enum {number}
2134
+ */
2135
+ proto.engine_api.EnclaveAPIContainerStatus = {
2136
+ ENCLAVEAPICONTAINERSTATUS_NONEXISTENT: 0,
2137
+ ENCLAVEAPICONTAINERSTATUS_RUNNING: 1,
2138
+ ENCLAVEAPICONTAINERSTATUS_STOPPED: 2
2139
+ };
2140
+
2141
+ goog.object.extend(exports, proto.engine_api);