spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
1,156 lines • 96.8 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RecordDataBlobsResponse_Error = exports.RecordDataBlobsResponse = exports.RecordOperatorCommentsResponse_Error = exports.RecordOperatorCommentsResponse = exports.RecordTextMessagesResponse_Error = exports.RecordTextMessagesResponse = exports.Event = exports.SignalTick = exports.SignalSchemaId = exports.SignalSchema_Variable = exports.SignalSchema = exports.DataBlob = exports.OperatorComment = exports.TextMessage = exports.RecordEventsRequest = exports.RecordSignalTicksRequest = exports.RecordDataBlobsRequest = exports.RecordOperatorCommentsRequest = exports.RecordTextMessagesRequest = exports.recordEventsResponse_Error_TypeToJSON = exports.recordEventsResponse_Error_TypeFromJSON = exports.RecordEventsResponse_Error_Type = exports.recordSignalTicksResponse_Error_TypeToJSON = exports.recordSignalTicksResponse_Error_TypeFromJSON = exports.RecordSignalTicksResponse_Error_Type = exports.recordDataBlobsResponse_Error_TypeToJSON = exports.recordDataBlobsResponse_Error_TypeFromJSON = exports.RecordDataBlobsResponse_Error_Type = exports.recordOperatorCommentsResponse_Error_TypeToJSON = exports.recordOperatorCommentsResponse_Error_TypeFromJSON = exports.RecordOperatorCommentsResponse_Error_Type = exports.recordTextMessagesResponse_Error_TypeToJSON = exports.recordTextMessagesResponse_Error_TypeFromJSON = exports.RecordTextMessagesResponse_Error_Type = exports.event_LogPreserveHintToJSON = exports.event_LogPreserveHintFromJSON = exports.Event_LogPreserveHint = exports.event_LevelToJSON = exports.event_LevelFromJSON = exports.Event_Level = exports.signalTick_EncodingToJSON = exports.signalTick_EncodingFromJSON = exports.SignalTick_Encoding = exports.signalSchema_Variable_TypeToJSON = exports.signalSchema_Variable_TypeFromJSON = exports.SignalSchema_Variable_Type = exports.textMessage_LevelToJSON = exports.textMessage_LevelFromJSON = exports.TextMessage_Level = exports.protobufPackage = void 0;
exports.RegisterSignalSchemaResponse = exports.RegisterSignalSchemaRequest = exports.RecordEventsResponse_Error = exports.RecordEventsResponse = exports.RecordSignalTicksResponse_Error = exports.RecordSignalTicksResponse = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const long_1 = __importDefault(require("long"));
const header_1 = require("./header");
const parameter_1 = require("./parameter");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
var TextMessage_Level;
(function (TextMessage_Level) {
/** LEVEL_UNKNOWN - Invalid, do not use. */
TextMessage_Level[TextMessage_Level["LEVEL_UNKNOWN"] = 0] = "LEVEL_UNKNOWN";
/** LEVEL_DEBUG - Events likely of interest only in a debugging context. */
TextMessage_Level[TextMessage_Level["LEVEL_DEBUG"] = 1] = "LEVEL_DEBUG";
/** LEVEL_INFO - Informational message during normal operation. */
TextMessage_Level[TextMessage_Level["LEVEL_INFO"] = 2] = "LEVEL_INFO";
/** LEVEL_WARN - Information about an unexpected but recoverable condition. */
TextMessage_Level[TextMessage_Level["LEVEL_WARN"] = 3] = "LEVEL_WARN";
/** LEVEL_ERROR - Information about an operation which did not succeed. */
TextMessage_Level[TextMessage_Level["LEVEL_ERROR"] = 4] = "LEVEL_ERROR";
TextMessage_Level[TextMessage_Level["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(TextMessage_Level = exports.TextMessage_Level || (exports.TextMessage_Level = {}));
function textMessage_LevelFromJSON(object) {
switch (object) {
case 0:
case "LEVEL_UNKNOWN":
return TextMessage_Level.LEVEL_UNKNOWN;
case 1:
case "LEVEL_DEBUG":
return TextMessage_Level.LEVEL_DEBUG;
case 2:
case "LEVEL_INFO":
return TextMessage_Level.LEVEL_INFO;
case 3:
case "LEVEL_WARN":
return TextMessage_Level.LEVEL_WARN;
case 4:
case "LEVEL_ERROR":
return TextMessage_Level.LEVEL_ERROR;
case -1:
case "UNRECOGNIZED":
default:
return TextMessage_Level.UNRECOGNIZED;
}
}
exports.textMessage_LevelFromJSON = textMessage_LevelFromJSON;
function textMessage_LevelToJSON(object) {
switch (object) {
case TextMessage_Level.LEVEL_UNKNOWN:
return "LEVEL_UNKNOWN";
case TextMessage_Level.LEVEL_DEBUG:
return "LEVEL_DEBUG";
case TextMessage_Level.LEVEL_INFO:
return "LEVEL_INFO";
case TextMessage_Level.LEVEL_WARN:
return "LEVEL_WARN";
case TextMessage_Level.LEVEL_ERROR:
return "LEVEL_ERROR";
case TextMessage_Level.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.textMessage_LevelToJSON = textMessage_LevelToJSON;
var SignalSchema_Variable_Type;
(function (SignalSchema_Variable_Type) {
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_UNKNOWN"] = 0] = "TYPE_UNKNOWN";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_INT8"] = 1] = "TYPE_INT8";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_INT16"] = 2] = "TYPE_INT16";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_INT32"] = 3] = "TYPE_INT32";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_INT64"] = 4] = "TYPE_INT64";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_UINT8"] = 5] = "TYPE_UINT8";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_UINT16"] = 6] = "TYPE_UINT16";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_UINT32"] = 7] = "TYPE_UINT32";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_UINT64"] = 8] = "TYPE_UINT64";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_FLOAT32"] = 9] = "TYPE_FLOAT32";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["TYPE_FLOAT64"] = 10] = "TYPE_FLOAT64";
SignalSchema_Variable_Type[SignalSchema_Variable_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(SignalSchema_Variable_Type = exports.SignalSchema_Variable_Type || (exports.SignalSchema_Variable_Type = {}));
function signalSchema_Variable_TypeFromJSON(object) {
switch (object) {
case 0:
case "TYPE_UNKNOWN":
return SignalSchema_Variable_Type.TYPE_UNKNOWN;
case 1:
case "TYPE_INT8":
return SignalSchema_Variable_Type.TYPE_INT8;
case 2:
case "TYPE_INT16":
return SignalSchema_Variable_Type.TYPE_INT16;
case 3:
case "TYPE_INT32":
return SignalSchema_Variable_Type.TYPE_INT32;
case 4:
case "TYPE_INT64":
return SignalSchema_Variable_Type.TYPE_INT64;
case 5:
case "TYPE_UINT8":
return SignalSchema_Variable_Type.TYPE_UINT8;
case 6:
case "TYPE_UINT16":
return SignalSchema_Variable_Type.TYPE_UINT16;
case 7:
case "TYPE_UINT32":
return SignalSchema_Variable_Type.TYPE_UINT32;
case 8:
case "TYPE_UINT64":
return SignalSchema_Variable_Type.TYPE_UINT64;
case 9:
case "TYPE_FLOAT32":
return SignalSchema_Variable_Type.TYPE_FLOAT32;
case 10:
case "TYPE_FLOAT64":
return SignalSchema_Variable_Type.TYPE_FLOAT64;
case -1:
case "UNRECOGNIZED":
default:
return SignalSchema_Variable_Type.UNRECOGNIZED;
}
}
exports.signalSchema_Variable_TypeFromJSON = signalSchema_Variable_TypeFromJSON;
function signalSchema_Variable_TypeToJSON(object) {
switch (object) {
case SignalSchema_Variable_Type.TYPE_UNKNOWN:
return "TYPE_UNKNOWN";
case SignalSchema_Variable_Type.TYPE_INT8:
return "TYPE_INT8";
case SignalSchema_Variable_Type.TYPE_INT16:
return "TYPE_INT16";
case SignalSchema_Variable_Type.TYPE_INT32:
return "TYPE_INT32";
case SignalSchema_Variable_Type.TYPE_INT64:
return "TYPE_INT64";
case SignalSchema_Variable_Type.TYPE_UINT8:
return "TYPE_UINT8";
case SignalSchema_Variable_Type.TYPE_UINT16:
return "TYPE_UINT16";
case SignalSchema_Variable_Type.TYPE_UINT32:
return "TYPE_UINT32";
case SignalSchema_Variable_Type.TYPE_UINT64:
return "TYPE_UINT64";
case SignalSchema_Variable_Type.TYPE_FLOAT32:
return "TYPE_FLOAT32";
case SignalSchema_Variable_Type.TYPE_FLOAT64:
return "TYPE_FLOAT64";
case SignalSchema_Variable_Type.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.signalSchema_Variable_TypeToJSON = signalSchema_Variable_TypeToJSON;
var SignalTick_Encoding;
(function (SignalTick_Encoding) {
SignalTick_Encoding[SignalTick_Encoding["ENCODING_UNKNOWN"] = 0] = "ENCODING_UNKNOWN";
/**
* ENCODING_RAW - Bytes array is a concatination of little-endian machine representations of
* the variables from the SignalSchema, in order listed in that schema.
*/
SignalTick_Encoding[SignalTick_Encoding["ENCODING_RAW"] = 1] = "ENCODING_RAW";
SignalTick_Encoding[SignalTick_Encoding["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(SignalTick_Encoding = exports.SignalTick_Encoding || (exports.SignalTick_Encoding = {}));
function signalTick_EncodingFromJSON(object) {
switch (object) {
case 0:
case "ENCODING_UNKNOWN":
return SignalTick_Encoding.ENCODING_UNKNOWN;
case 1:
case "ENCODING_RAW":
return SignalTick_Encoding.ENCODING_RAW;
case -1:
case "UNRECOGNIZED":
default:
return SignalTick_Encoding.UNRECOGNIZED;
}
}
exports.signalTick_EncodingFromJSON = signalTick_EncodingFromJSON;
function signalTick_EncodingToJSON(object) {
switch (object) {
case SignalTick_Encoding.ENCODING_UNKNOWN:
return "ENCODING_UNKNOWN";
case SignalTick_Encoding.ENCODING_RAW:
return "ENCODING_RAW";
case SignalTick_Encoding.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.signalTick_EncodingToJSON = signalTick_EncodingToJSON;
/**
* Level, or similarly "visibility," "importance," or "weight" of event.
* - Higher level events will increase the visibility on the event timeline, relative to other
* events.
* - In general, higher level events should be more consequential with respect to the robot
* operation on a per-occurence basis.
* - Lower level events should be less consequential on a per occurence basis.
* - Non-critical events may be one of LOW, MEDIUM, or HIGH. UNSET is logically equivalent to
* LOW level.
* - Critical events may be either mission or system critical.
* - System-critical is quasi-reserved for internal robot use, and is used to identify events
* that directly affect robot status or capability, such as the onset of a critical fault or
* start of an enabling capability.
* - Mission-critical is quasi-reserved client use, and is intended for events that directly
* affect the ability of the robot to "do what the user wants," such as the onset of a
* service fault or start of an enabling capability.
*/
var Event_Level;
(function (Event_Level) {
Event_Level[Event_Level["LEVEL_UNSET"] = 0] = "LEVEL_UNSET";
/** LEVEL_LOW - Non-critical events */
Event_Level[Event_Level["LEVEL_LOW"] = 1] = "LEVEL_LOW";
Event_Level[Event_Level["LEVEL_MEDIUM"] = 2] = "LEVEL_MEDIUM";
Event_Level[Event_Level["LEVEL_HIGH"] = 3] = "LEVEL_HIGH";
/** LEVEL_MISSION_CRITICAL - Critical events */
Event_Level[Event_Level["LEVEL_MISSION_CRITICAL"] = 4] = "LEVEL_MISSION_CRITICAL";
Event_Level[Event_Level["LEVEL_SYSTEM_CRITICAL"] = 5] = "LEVEL_SYSTEM_CRITICAL";
Event_Level[Event_Level["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Event_Level = exports.Event_Level || (exports.Event_Level = {}));
function event_LevelFromJSON(object) {
switch (object) {
case 0:
case "LEVEL_UNSET":
return Event_Level.LEVEL_UNSET;
case 1:
case "LEVEL_LOW":
return Event_Level.LEVEL_LOW;
case 2:
case "LEVEL_MEDIUM":
return Event_Level.LEVEL_MEDIUM;
case 3:
case "LEVEL_HIGH":
return Event_Level.LEVEL_HIGH;
case 4:
case "LEVEL_MISSION_CRITICAL":
return Event_Level.LEVEL_MISSION_CRITICAL;
case 5:
case "LEVEL_SYSTEM_CRITICAL":
return Event_Level.LEVEL_SYSTEM_CRITICAL;
case -1:
case "UNRECOGNIZED":
default:
return Event_Level.UNRECOGNIZED;
}
}
exports.event_LevelFromJSON = event_LevelFromJSON;
function event_LevelToJSON(object) {
switch (object) {
case Event_Level.LEVEL_UNSET:
return "LEVEL_UNSET";
case Event_Level.LEVEL_LOW:
return "LEVEL_LOW";
case Event_Level.LEVEL_MEDIUM:
return "LEVEL_MEDIUM";
case Event_Level.LEVEL_HIGH:
return "LEVEL_HIGH";
case Event_Level.LEVEL_MISSION_CRITICAL:
return "LEVEL_MISSION_CRITICAL";
case Event_Level.LEVEL_SYSTEM_CRITICAL:
return "LEVEL_SYSTEM_CRITICAL";
case Event_Level.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.event_LevelToJSON = event_LevelToJSON;
/**
* LogPreserveHint may encode a hint to the robot's logging system for whether to preserve
* internal log data near the time of this event. This could be useful in saving data
* to be used in a service log to send to Boston Dynamics.
*/
var Event_LogPreserveHint;
(function (Event_LogPreserveHint) {
/** LOG_PRESERVE_HINT_UNSET - If this this is unset, it is equivalent to LOG_PRESERVE_HINT_NORMAL. */
Event_LogPreserveHint[Event_LogPreserveHint["LOG_PRESERVE_HINT_UNSET"] = 0] = "LOG_PRESERVE_HINT_UNSET";
/**
* LOG_PRESERVE_HINT_NORMAL - Do not change the robot's default log data preservation behavior in response to this
* event.
*/
Event_LogPreserveHint[Event_LogPreserveHint["LOG_PRESERVE_HINT_NORMAL"] = 1] = "LOG_PRESERVE_HINT_NORMAL";
/**
* LOG_PRESERVE_HINT_PRESERVE - Request that the robot try to preserve data near the time of this event.
* Log space on the robot is limited, so this does not guarentee that the data will be
* preserved.
*/
Event_LogPreserveHint[Event_LogPreserveHint["LOG_PRESERVE_HINT_PRESERVE"] = 2] = "LOG_PRESERVE_HINT_PRESERVE";
Event_LogPreserveHint[Event_LogPreserveHint["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Event_LogPreserveHint = exports.Event_LogPreserveHint || (exports.Event_LogPreserveHint = {}));
function event_LogPreserveHintFromJSON(object) {
switch (object) {
case 0:
case "LOG_PRESERVE_HINT_UNSET":
return Event_LogPreserveHint.LOG_PRESERVE_HINT_UNSET;
case 1:
case "LOG_PRESERVE_HINT_NORMAL":
return Event_LogPreserveHint.LOG_PRESERVE_HINT_NORMAL;
case 2:
case "LOG_PRESERVE_HINT_PRESERVE":
return Event_LogPreserveHint.LOG_PRESERVE_HINT_PRESERVE;
case -1:
case "UNRECOGNIZED":
default:
return Event_LogPreserveHint.UNRECOGNIZED;
}
}
exports.event_LogPreserveHintFromJSON = event_LogPreserveHintFromJSON;
function event_LogPreserveHintToJSON(object) {
switch (object) {
case Event_LogPreserveHint.LOG_PRESERVE_HINT_UNSET:
return "LOG_PRESERVE_HINT_UNSET";
case Event_LogPreserveHint.LOG_PRESERVE_HINT_NORMAL:
return "LOG_PRESERVE_HINT_NORMAL";
case Event_LogPreserveHint.LOG_PRESERVE_HINT_PRESERVE:
return "LOG_PRESERVE_HINT_PRESERVE";
case Event_LogPreserveHint.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.event_LogPreserveHintToJSON = event_LogPreserveHintToJSON;
var RecordTextMessagesResponse_Error_Type;
(function (RecordTextMessagesResponse_Error_Type) {
RecordTextMessagesResponse_Error_Type[RecordTextMessagesResponse_Error_Type["NONE"] = 0] = "NONE";
RecordTextMessagesResponse_Error_Type[RecordTextMessagesResponse_Error_Type["CLIENT_ERROR"] = 1] = "CLIENT_ERROR";
RecordTextMessagesResponse_Error_Type[RecordTextMessagesResponse_Error_Type["SERVER_ERROR"] = 2] = "SERVER_ERROR";
RecordTextMessagesResponse_Error_Type[RecordTextMessagesResponse_Error_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(RecordTextMessagesResponse_Error_Type = exports.RecordTextMessagesResponse_Error_Type || (exports.RecordTextMessagesResponse_Error_Type = {}));
function recordTextMessagesResponse_Error_TypeFromJSON(object) {
switch (object) {
case 0:
case "NONE":
return RecordTextMessagesResponse_Error_Type.NONE;
case 1:
case "CLIENT_ERROR":
return RecordTextMessagesResponse_Error_Type.CLIENT_ERROR;
case 2:
case "SERVER_ERROR":
return RecordTextMessagesResponse_Error_Type.SERVER_ERROR;
case -1:
case "UNRECOGNIZED":
default:
return RecordTextMessagesResponse_Error_Type.UNRECOGNIZED;
}
}
exports.recordTextMessagesResponse_Error_TypeFromJSON = recordTextMessagesResponse_Error_TypeFromJSON;
function recordTextMessagesResponse_Error_TypeToJSON(object) {
switch (object) {
case RecordTextMessagesResponse_Error_Type.NONE:
return "NONE";
case RecordTextMessagesResponse_Error_Type.CLIENT_ERROR:
return "CLIENT_ERROR";
case RecordTextMessagesResponse_Error_Type.SERVER_ERROR:
return "SERVER_ERROR";
case RecordTextMessagesResponse_Error_Type.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.recordTextMessagesResponse_Error_TypeToJSON = recordTextMessagesResponse_Error_TypeToJSON;
var RecordOperatorCommentsResponse_Error_Type;
(function (RecordOperatorCommentsResponse_Error_Type) {
RecordOperatorCommentsResponse_Error_Type[RecordOperatorCommentsResponse_Error_Type["NONE"] = 0] = "NONE";
RecordOperatorCommentsResponse_Error_Type[RecordOperatorCommentsResponse_Error_Type["CLIENT_ERROR"] = 1] = "CLIENT_ERROR";
RecordOperatorCommentsResponse_Error_Type[RecordOperatorCommentsResponse_Error_Type["SERVER_ERROR"] = 2] = "SERVER_ERROR";
RecordOperatorCommentsResponse_Error_Type[RecordOperatorCommentsResponse_Error_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(RecordOperatorCommentsResponse_Error_Type = exports.RecordOperatorCommentsResponse_Error_Type || (exports.RecordOperatorCommentsResponse_Error_Type = {}));
function recordOperatorCommentsResponse_Error_TypeFromJSON(object) {
switch (object) {
case 0:
case "NONE":
return RecordOperatorCommentsResponse_Error_Type.NONE;
case 1:
case "CLIENT_ERROR":
return RecordOperatorCommentsResponse_Error_Type.CLIENT_ERROR;
case 2:
case "SERVER_ERROR":
return RecordOperatorCommentsResponse_Error_Type.SERVER_ERROR;
case -1:
case "UNRECOGNIZED":
default:
return RecordOperatorCommentsResponse_Error_Type.UNRECOGNIZED;
}
}
exports.recordOperatorCommentsResponse_Error_TypeFromJSON = recordOperatorCommentsResponse_Error_TypeFromJSON;
function recordOperatorCommentsResponse_Error_TypeToJSON(object) {
switch (object) {
case RecordOperatorCommentsResponse_Error_Type.NONE:
return "NONE";
case RecordOperatorCommentsResponse_Error_Type.CLIENT_ERROR:
return "CLIENT_ERROR";
case RecordOperatorCommentsResponse_Error_Type.SERVER_ERROR:
return "SERVER_ERROR";
case RecordOperatorCommentsResponse_Error_Type.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.recordOperatorCommentsResponse_Error_TypeToJSON = recordOperatorCommentsResponse_Error_TypeToJSON;
var RecordDataBlobsResponse_Error_Type;
(function (RecordDataBlobsResponse_Error_Type) {
RecordDataBlobsResponse_Error_Type[RecordDataBlobsResponse_Error_Type["NONE"] = 0] = "NONE";
RecordDataBlobsResponse_Error_Type[RecordDataBlobsResponse_Error_Type["CLIENT_ERROR"] = 1] = "CLIENT_ERROR";
RecordDataBlobsResponse_Error_Type[RecordDataBlobsResponse_Error_Type["SERVER_ERROR"] = 2] = "SERVER_ERROR";
RecordDataBlobsResponse_Error_Type[RecordDataBlobsResponse_Error_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(RecordDataBlobsResponse_Error_Type = exports.RecordDataBlobsResponse_Error_Type || (exports.RecordDataBlobsResponse_Error_Type = {}));
function recordDataBlobsResponse_Error_TypeFromJSON(object) {
switch (object) {
case 0:
case "NONE":
return RecordDataBlobsResponse_Error_Type.NONE;
case 1:
case "CLIENT_ERROR":
return RecordDataBlobsResponse_Error_Type.CLIENT_ERROR;
case 2:
case "SERVER_ERROR":
return RecordDataBlobsResponse_Error_Type.SERVER_ERROR;
case -1:
case "UNRECOGNIZED":
default:
return RecordDataBlobsResponse_Error_Type.UNRECOGNIZED;
}
}
exports.recordDataBlobsResponse_Error_TypeFromJSON = recordDataBlobsResponse_Error_TypeFromJSON;
function recordDataBlobsResponse_Error_TypeToJSON(object) {
switch (object) {
case RecordDataBlobsResponse_Error_Type.NONE:
return "NONE";
case RecordDataBlobsResponse_Error_Type.CLIENT_ERROR:
return "CLIENT_ERROR";
case RecordDataBlobsResponse_Error_Type.SERVER_ERROR:
return "SERVER_ERROR";
case RecordDataBlobsResponse_Error_Type.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.recordDataBlobsResponse_Error_TypeToJSON = recordDataBlobsResponse_Error_TypeToJSON;
var RecordSignalTicksResponse_Error_Type;
(function (RecordSignalTicksResponse_Error_Type) {
RecordSignalTicksResponse_Error_Type[RecordSignalTicksResponse_Error_Type["NONE"] = 0] = "NONE";
RecordSignalTicksResponse_Error_Type[RecordSignalTicksResponse_Error_Type["CLIENT_ERROR"] = 1] = "CLIENT_ERROR";
RecordSignalTicksResponse_Error_Type[RecordSignalTicksResponse_Error_Type["SERVER_ERROR"] = 2] = "SERVER_ERROR";
RecordSignalTicksResponse_Error_Type[RecordSignalTicksResponse_Error_Type["INVALID_SCHEMA_ID"] = 3] = "INVALID_SCHEMA_ID";
RecordSignalTicksResponse_Error_Type[RecordSignalTicksResponse_Error_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(RecordSignalTicksResponse_Error_Type = exports.RecordSignalTicksResponse_Error_Type || (exports.RecordSignalTicksResponse_Error_Type = {}));
function recordSignalTicksResponse_Error_TypeFromJSON(object) {
switch (object) {
case 0:
case "NONE":
return RecordSignalTicksResponse_Error_Type.NONE;
case 1:
case "CLIENT_ERROR":
return RecordSignalTicksResponse_Error_Type.CLIENT_ERROR;
case 2:
case "SERVER_ERROR":
return RecordSignalTicksResponse_Error_Type.SERVER_ERROR;
case 3:
case "INVALID_SCHEMA_ID":
return RecordSignalTicksResponse_Error_Type.INVALID_SCHEMA_ID;
case -1:
case "UNRECOGNIZED":
default:
return RecordSignalTicksResponse_Error_Type.UNRECOGNIZED;
}
}
exports.recordSignalTicksResponse_Error_TypeFromJSON = recordSignalTicksResponse_Error_TypeFromJSON;
function recordSignalTicksResponse_Error_TypeToJSON(object) {
switch (object) {
case RecordSignalTicksResponse_Error_Type.NONE:
return "NONE";
case RecordSignalTicksResponse_Error_Type.CLIENT_ERROR:
return "CLIENT_ERROR";
case RecordSignalTicksResponse_Error_Type.SERVER_ERROR:
return "SERVER_ERROR";
case RecordSignalTicksResponse_Error_Type.INVALID_SCHEMA_ID:
return "INVALID_SCHEMA_ID";
case RecordSignalTicksResponse_Error_Type.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.recordSignalTicksResponse_Error_TypeToJSON = recordSignalTicksResponse_Error_TypeToJSON;
var RecordEventsResponse_Error_Type;
(function (RecordEventsResponse_Error_Type) {
RecordEventsResponse_Error_Type[RecordEventsResponse_Error_Type["NONE"] = 0] = "NONE";
RecordEventsResponse_Error_Type[RecordEventsResponse_Error_Type["CLIENT_ERROR"] = 1] = "CLIENT_ERROR";
RecordEventsResponse_Error_Type[RecordEventsResponse_Error_Type["SERVER_ERROR"] = 2] = "SERVER_ERROR";
RecordEventsResponse_Error_Type[RecordEventsResponse_Error_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(RecordEventsResponse_Error_Type = exports.RecordEventsResponse_Error_Type || (exports.RecordEventsResponse_Error_Type = {}));
function recordEventsResponse_Error_TypeFromJSON(object) {
switch (object) {
case 0:
case "NONE":
return RecordEventsResponse_Error_Type.NONE;
case 1:
case "CLIENT_ERROR":
return RecordEventsResponse_Error_Type.CLIENT_ERROR;
case 2:
case "SERVER_ERROR":
return RecordEventsResponse_Error_Type.SERVER_ERROR;
case -1:
case "UNRECOGNIZED":
default:
return RecordEventsResponse_Error_Type.UNRECOGNIZED;
}
}
exports.recordEventsResponse_Error_TypeFromJSON = recordEventsResponse_Error_TypeFromJSON;
function recordEventsResponse_Error_TypeToJSON(object) {
switch (object) {
case RecordEventsResponse_Error_Type.NONE:
return "NONE";
case RecordEventsResponse_Error_Type.CLIENT_ERROR:
return "CLIENT_ERROR";
case RecordEventsResponse_Error_Type.SERVER_ERROR:
return "SERVER_ERROR";
case RecordEventsResponse_Error_Type.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.recordEventsResponse_Error_TypeToJSON = recordEventsResponse_Error_TypeToJSON;
function createBaseRecordTextMessagesRequest() {
return { header: undefined, textMessages: [] };
}
exports.RecordTextMessagesRequest = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.header !== undefined) {
header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
}
for (const v of message.textMessages) {
exports.TextMessage.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRecordTextMessagesRequest();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.RequestHeader.decode(reader, reader.uint32());
break;
case 2:
message.textMessages.push(exports.TextMessage.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.RequestHeader.fromJSON(object.header)
: undefined,
textMessages: Array.isArray(object?.textMessages)
? object.textMessages.map((e) => exports.TextMessage.fromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.RequestHeader.toJSON(message.header)
: undefined);
if (message.textMessages) {
obj.textMessages = message.textMessages.map((e) => e ? exports.TextMessage.toJSON(e) : undefined);
}
else {
obj.textMessages = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseRecordTextMessagesRequest();
message.header =
object.header !== undefined && object.header !== null
? header_1.RequestHeader.fromPartial(object.header)
: undefined;
message.textMessages =
object.textMessages?.map((e) => exports.TextMessage.fromPartial(e)) || [];
return message;
},
};
function createBaseRecordOperatorCommentsRequest() {
return { header: undefined, operatorComments: [] };
}
exports.RecordOperatorCommentsRequest = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.header !== undefined) {
header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
}
for (const v of message.operatorComments) {
exports.OperatorComment.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRecordOperatorCommentsRequest();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.RequestHeader.decode(reader, reader.uint32());
break;
case 2:
message.operatorComments.push(exports.OperatorComment.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.RequestHeader.fromJSON(object.header)
: undefined,
operatorComments: Array.isArray(object?.operatorComments)
? object.operatorComments.map((e) => exports.OperatorComment.fromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.RequestHeader.toJSON(message.header)
: undefined);
if (message.operatorComments) {
obj.operatorComments = message.operatorComments.map((e) => e ? exports.OperatorComment.toJSON(e) : undefined);
}
else {
obj.operatorComments = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseRecordOperatorCommentsRequest();
message.header =
object.header !== undefined && object.header !== null
? header_1.RequestHeader.fromPartial(object.header)
: undefined;
message.operatorComments =
object.operatorComments?.map((e) => exports.OperatorComment.fromPartial(e)) || [];
return message;
},
};
function createBaseRecordDataBlobsRequest() {
return { header: undefined, blobData: [], sync: false };
}
exports.RecordDataBlobsRequest = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.header !== undefined) {
header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
}
for (const v of message.blobData) {
exports.DataBlob.encode(v, writer.uint32(18).fork()).ldelim();
}
if (message.sync === true) {
writer.uint32(24).bool(message.sync);
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRecordDataBlobsRequest();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.RequestHeader.decode(reader, reader.uint32());
break;
case 2:
message.blobData.push(exports.DataBlob.decode(reader, reader.uint32()));
break;
case 3:
message.sync = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.RequestHeader.fromJSON(object.header)
: undefined,
blobData: Array.isArray(object?.blobData)
? object.blobData.map((e) => exports.DataBlob.fromJSON(e))
: [],
sync: isSet(object.sync) ? Boolean(object.sync) : false,
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.RequestHeader.toJSON(message.header)
: undefined);
if (message.blobData) {
obj.blobData = message.blobData.map((e) => e ? exports.DataBlob.toJSON(e) : undefined);
}
else {
obj.blobData = [];
}
message.sync !== undefined && (obj.sync = message.sync);
return obj;
},
fromPartial(object) {
const message = createBaseRecordDataBlobsRequest();
message.header =
object.header !== undefined && object.header !== null
? header_1.RequestHeader.fromPartial(object.header)
: undefined;
message.blobData =
object.blobData?.map((e) => exports.DataBlob.fromPartial(e)) || [];
message.sync = object.sync ?? false;
return message;
},
};
function createBaseRecordSignalTicksRequest() {
return { header: undefined, tickData: [] };
}
exports.RecordSignalTicksRequest = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.header !== undefined) {
header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
}
for (const v of message.tickData) {
exports.SignalTick.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRecordSignalTicksRequest();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.RequestHeader.decode(reader, reader.uint32());
break;
case 2:
message.tickData.push(exports.SignalTick.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.RequestHeader.fromJSON(object.header)
: undefined,
tickData: Array.isArray(object?.tickData)
? object.tickData.map((e) => exports.SignalTick.fromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.RequestHeader.toJSON(message.header)
: undefined);
if (message.tickData) {
obj.tickData = message.tickData.map((e) => e ? exports.SignalTick.toJSON(e) : undefined);
}
else {
obj.tickData = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseRecordSignalTicksRequest();
message.header =
object.header !== undefined && object.header !== null
? header_1.RequestHeader.fromPartial(object.header)
: undefined;
message.tickData =
object.tickData?.map((e) => exports.SignalTick.fromPartial(e)) || [];
return message;
},
};
function createBaseRecordEventsRequest() {
return { header: undefined, events: [] };
}
exports.RecordEventsRequest = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.header !== undefined) {
header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
}
for (const v of message.events) {
exports.Event.encode(v, writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRecordEventsRequest();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.RequestHeader.decode(reader, reader.uint32());
break;
case 2:
message.events.push(exports.Event.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.RequestHeader.fromJSON(object.header)
: undefined,
events: Array.isArray(object?.events)
? object.events.map((e) => exports.Event.fromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.RequestHeader.toJSON(message.header)
: undefined);
if (message.events) {
obj.events = message.events.map((e) => (e ? exports.Event.toJSON(e) : undefined));
}
else {
obj.events = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseRecordEventsRequest();
message.header =
object.header !== undefined && object.header !== null
? header_1.RequestHeader.fromPartial(object.header)
: undefined;
message.events = object.events?.map((e) => exports.Event.fromPartial(e)) || [];
return message;
},
};
function createBaseTextMessage() {
return {
message: "",
timestamp: undefined,
source: "",
level: 0,
tag: "",
filename: "",
lineNumber: 0,
};
}
exports.TextMessage = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.message !== "") {
writer.uint32(10).string(message.message);
}
if (message.timestamp !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(18).fork()).ldelim();
}
if (message.source !== "") {
writer.uint32(26).string(message.source);
}
if (message.level !== 0) {
writer.uint32(32).int32(message.level);
}
if (message.tag !== "") {
writer.uint32(42).string(message.tag);
}
if (message.filename !== "") {
writer.uint32(50).string(message.filename);
}
if (message.lineNumber !== 0) {
writer.uint32(56).int32(message.lineNumber);
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseTextMessage();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.message = reader.string();
break;
case 2:
message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
break;
case 3:
message.source = reader.string();
break;
case 4:
message.level = reader.int32();
break;
case 5:
message.tag = reader.string();
break;
case 6:
message.filename = reader.string();
break;
case 7:
message.lineNumber = reader.int32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
message: isSet(object.message) ? String(object.message) : "",
timestamp: isSet(object.timestamp)
? fromJsonTimestamp(object.timestamp)
: undefined,
source: isSet(object.source) ? String(object.source) : "",
level: isSet(object.level) ? textMessage_LevelFromJSON(object.level) : 0,
tag: isSet(object.tag) ? String(object.tag) : "",
filename: isSet(object.filename) ? String(object.filename) : "",
lineNumber: isSet(object.lineNumber) ? Number(object.lineNumber) : 0,
};
},
toJSON(message) {
const obj = {};
message.message !== undefined && (obj.message = message.message);
message.timestamp !== undefined &&
(obj.timestamp = message.timestamp.toISOString());
message.source !== undefined && (obj.source = message.source);
message.level !== undefined &&
(obj.level = textMessage_LevelToJSON(message.level));
message.tag !== undefined && (obj.tag = message.tag);
message.filename !== undefined && (obj.filename = message.filename);
message.lineNumber !== undefined &&
(obj.lineNumber = Math.round(message.lineNumber));
return obj;
},
fromPartial(object) {
const message = createBaseTextMessage();
message.message = object.message ?? "";
message.timestamp = object.timestamp ?? undefined;
message.source = object.source ?? "";
message.level = object.level ?? 0;
message.tag = object.tag ?? "";
message.filename = object.filename ?? "";
message.lineNumber = object.lineNumber ?? 0;
return message;
},
};
function createBaseOperatorComment() {
return { message: "", timestamp: undefined };
}
exports.OperatorComment = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.message !== "") {
writer.uint32(10).string(message.message);
}
if (message.timestamp !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(18).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseOperatorComment();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.message = reader.string();
break;
case 2:
message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
message: isSet(object.message) ? String(object.message) : "",
timestamp: isSet(object.timestamp)
? fromJsonTimestamp(object.timestamp)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.message !== undefined && (obj.message = message.message);
message.timestamp !== undefined &&
(obj.timestamp = message.timestamp.toISOString());
return obj;
},
fromPartial(object) {
const message = createBaseOperatorComment();
message.message = object.message ?? "";
message.timestamp = object.timestamp ?? undefined;
return message;
},
};
function createBaseDataBlob() {
return {
timestamp: undefined,
channel: "",
typeId: "",
data: new Uint8Array(),
};
}
exports.DataBlob = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.timestamp !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(10).fork()).ldelim();
}
if (message.channel !== "") {
writer.uint32(18).string(message.channel);
}
if (message.typeId !== "") {
writer.uint32(26).string(message.typeId);
}
if (message.data.length !== 0) {
writer.uint32(34).bytes(message.data);
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseDataBlob();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
break;
case 2:
message.channel = reader.string();
break;
case 3:
message.typeId = reader.string();
break;
case 4:
message.data = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
timestamp: isSet(object.timestamp)
? fromJsonTimestamp(object.timestamp)
: undefined,
channel: isSet(object.channel) ? String(object.channel) : "",
typeId: isSet(object.typeId) ? String(object.typeId) : "",
data: isSet(object.data)
? bytesFromBase64(object.data)
: new Uint8Array(),
};
},
toJSON(message) {
const obj = {};
message.timestamp !== undefined &&
(obj.timestamp = message.timestamp.toISOString());
message.channel !== undefined && (obj.channel = message.channel);
message.typeId !== undefined && (obj.typeId = message.typeId);
message.data !== undefined &&
(obj.data = base64FromBytes(message.data !== undefined ? message.data : new Uint8Array()));
return obj;
},
fromPartial(object) {
const message = createBaseDataBlob();
message.timestamp = object.timestamp ?? undefined;
message.channel = object.channel ?? "";
message.typeId = object.typeId ?? "";
message.data = object.data ?? new Uint8Array();
return message;
},
};
function createBaseSignalSchema() {
return { vars: [], schemaName: "" };
}
exports.SignalSchema = {
encode(message, writer = minimal_1.default.Writer.create()) {
for (const v of message.vars) {
exports.SignalSchema_Variable.encode(v, writer.uint32(10).fork()).ldelim();
}
if (message.schemaName !== "") {
writer.uint32(18).string(message.schemaName);
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseSignalSchema();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.vars.push(exports.SignalSchema_Variable.decode(reader, reader.uint32()));
break;
case 2:
message.schemaName = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
vars: Array.isArray(object?.vars)
? object.vars.map((e) => exports.SignalSchema_Va