spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
618 lines • 24.8 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AddLogAnnotationResponse = exports.LogAnnotationLogBlob = exports.LogAnnotationOperatorMessage = exports.LogAnnotationTextMessage = exports.LogAnnotations = exports.AddLogAnnotationRequest = exports.logAnnotationTextMessage_LevelToJSON = exports.logAnnotationTextMessage_LevelFromJSON = exports.LogAnnotationTextMessage_Level = exports.protobufPackage = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const header_1 = require("./header");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
var LogAnnotationTextMessage_Level;
(function (LogAnnotationTextMessage_Level) {
/** LEVEL_UNKNOWN - Invalid, do not use. */
LogAnnotationTextMessage_Level[LogAnnotationTextMessage_Level["LEVEL_UNKNOWN"] = 0] = "LEVEL_UNKNOWN";
/** LEVEL_DEBUG - Events likely of interest only in a debugging context. */
LogAnnotationTextMessage_Level[LogAnnotationTextMessage_Level["LEVEL_DEBUG"] = 1] = "LEVEL_DEBUG";
/** LEVEL_INFO - Informational message during normal operation. */
LogAnnotationTextMessage_Level[LogAnnotationTextMessage_Level["LEVEL_INFO"] = 2] = "LEVEL_INFO";
/** LEVEL_WARN - Information about an unexpected but recoverable condition. */
LogAnnotationTextMessage_Level[LogAnnotationTextMessage_Level["LEVEL_WARN"] = 3] = "LEVEL_WARN";
/** LEVEL_ERROR - Information about an operation which did not succeed. */
LogAnnotationTextMessage_Level[LogAnnotationTextMessage_Level["LEVEL_ERROR"] = 4] = "LEVEL_ERROR";
LogAnnotationTextMessage_Level[LogAnnotationTextMessage_Level["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(LogAnnotationTextMessage_Level = exports.LogAnnotationTextMessage_Level || (exports.LogAnnotationTextMessage_Level = {}));
function logAnnotationTextMessage_LevelFromJSON(object) {
switch (object) {
case 0:
case "LEVEL_UNKNOWN":
return LogAnnotationTextMessage_Level.LEVEL_UNKNOWN;
case 1:
case "LEVEL_DEBUG":
return LogAnnotationTextMessage_Level.LEVEL_DEBUG;
case 2:
case "LEVEL_INFO":
return LogAnnotationTextMessage_Level.LEVEL_INFO;
case 3:
case "LEVEL_WARN":
return LogAnnotationTextMessage_Level.LEVEL_WARN;
case 4:
case "LEVEL_ERROR":
return LogAnnotationTextMessage_Level.LEVEL_ERROR;
case -1:
case "UNRECOGNIZED":
default:
return LogAnnotationTextMessage_Level.UNRECOGNIZED;
}
}
exports.logAnnotationTextMessage_LevelFromJSON = logAnnotationTextMessage_LevelFromJSON;
function logAnnotationTextMessage_LevelToJSON(object) {
switch (object) {
case LogAnnotationTextMessage_Level.LEVEL_UNKNOWN:
return "LEVEL_UNKNOWN";
case LogAnnotationTextMessage_Level.LEVEL_DEBUG:
return "LEVEL_DEBUG";
case LogAnnotationTextMessage_Level.LEVEL_INFO:
return "LEVEL_INFO";
case LogAnnotationTextMessage_Level.LEVEL_WARN:
return "LEVEL_WARN";
case LogAnnotationTextMessage_Level.LEVEL_ERROR:
return "LEVEL_ERROR";
case LogAnnotationTextMessage_Level.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.logAnnotationTextMessage_LevelToJSON = logAnnotationTextMessage_LevelToJSON;
function createBaseAddLogAnnotationRequest() {
return { header: undefined, annotations: undefined };
}
exports.AddLogAnnotationRequest = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.header !== undefined) {
header_1.RequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
}
if (message.annotations !== undefined) {
exports.LogAnnotations.encode(message.annotations, 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 = createBaseAddLogAnnotationRequest();
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.annotations = exports.LogAnnotations.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,
annotations: isSet(object.annotations)
? exports.LogAnnotations.fromJSON(object.annotations)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.RequestHeader.toJSON(message.header)
: undefined);
message.annotations !== undefined &&
(obj.annotations = message.annotations
? exports.LogAnnotations.toJSON(message.annotations)
: undefined);
return obj;
},
fromPartial(object) {
const message = createBaseAddLogAnnotationRequest();
message.header =
object.header !== undefined && object.header !== null
? header_1.RequestHeader.fromPartial(object.header)
: undefined;
message.annotations =
object.annotations !== undefined && object.annotations !== null
? exports.LogAnnotations.fromPartial(object.annotations)
: undefined;
return message;
},
};
function createBaseLogAnnotations() {
return { textMessages: [], operatorMessages: [], blobData: [] };
}
exports.LogAnnotations = {
encode(message, writer = minimal_1.default.Writer.create()) {
for (const v of message.textMessages) {
exports.LogAnnotationTextMessage.encode(v, writer.uint32(10).fork()).ldelim();
}
for (const v of message.operatorMessages) {
exports.LogAnnotationOperatorMessage.encode(v, writer.uint32(18).fork()).ldelim();
}
for (const v of message.blobData) {
exports.LogAnnotationLogBlob.encode(v, writer.uint32(26).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 = createBaseLogAnnotations();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.textMessages.push(exports.LogAnnotationTextMessage.decode(reader, reader.uint32()));
break;
case 2:
message.operatorMessages.push(exports.LogAnnotationOperatorMessage.decode(reader, reader.uint32()));
break;
case 3:
message.blobData.push(exports.LogAnnotationLogBlob.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
textMessages: Array.isArray(object?.textMessages)
? object.textMessages.map((e) => exports.LogAnnotationTextMessage.fromJSON(e))
: [],
operatorMessages: Array.isArray(object?.operatorMessages)
? object.operatorMessages.map((e) => exports.LogAnnotationOperatorMessage.fromJSON(e))
: [],
blobData: Array.isArray(object?.blobData)
? object.blobData.map((e) => exports.LogAnnotationLogBlob.fromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
if (message.textMessages) {
obj.textMessages = message.textMessages.map((e) => e ? exports.LogAnnotationTextMessage.toJSON(e) : undefined);
}
else {
obj.textMessages = [];
}
if (message.operatorMessages) {
obj.operatorMessages = message.operatorMessages.map((e) => e ? exports.LogAnnotationOperatorMessage.toJSON(e) : undefined);
}
else {
obj.operatorMessages = [];
}
if (message.blobData) {
obj.blobData = message.blobData.map((e) => e ? exports.LogAnnotationLogBlob.toJSON(e) : undefined);
}
else {
obj.blobData = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseLogAnnotations();
message.textMessages =
object.textMessages?.map((e) => exports.LogAnnotationTextMessage.fromPartial(e)) || [];
message.operatorMessages =
object.operatorMessages?.map((e) => exports.LogAnnotationOperatorMessage.fromPartial(e)) || [];
message.blobData =
object.blobData?.map((e) => exports.LogAnnotationLogBlob.fromPartial(e)) || [];
return message;
},
};
function createBaseLogAnnotationTextMessage() {
return {
message: "",
timestamp: undefined,
service: "",
level: 0,
tag: "",
filename: "",
lineNumber: 0,
timestampClient: undefined,
};
}
exports.LogAnnotationTextMessage = {
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.service !== "") {
writer.uint32(26).string(message.service);
}
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);
}
if (message.timestampClient !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.timestampClient), writer.uint32(66).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 = createBaseLogAnnotationTextMessage();
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.service = 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;
case 8:
message.timestampClient = 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,
service: isSet(object.service) ? String(object.service) : "",
level: isSet(object.level)
? logAnnotationTextMessage_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,
timestampClient: isSet(object.timestampClient)
? fromJsonTimestamp(object.timestampClient)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.message !== undefined && (obj.message = message.message);
message.timestamp !== undefined &&
(obj.timestamp = message.timestamp.toISOString());
message.service !== undefined && (obj.service = message.service);
message.level !== undefined &&
(obj.level = logAnnotationTextMessage_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));
message.timestampClient !== undefined &&
(obj.timestampClient = message.timestampClient.toISOString());
return obj;
},
fromPartial(object) {
const message = createBaseLogAnnotationTextMessage();
message.message = object.message ?? "";
message.timestamp = object.timestamp ?? undefined;
message.service = object.service ?? "";
message.level = object.level ?? 0;
message.tag = object.tag ?? "";
message.filename = object.filename ?? "";
message.lineNumber = object.lineNumber ?? 0;
message.timestampClient = object.timestampClient ?? undefined;
return message;
},
};
function createBaseLogAnnotationOperatorMessage() {
return { message: "", timestamp: undefined, timestampClient: undefined };
}
exports.LogAnnotationOperatorMessage = {
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.timestampClient !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.timestampClient), writer.uint32(26).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 = createBaseLogAnnotationOperatorMessage();
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.timestampClient = 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,
timestampClient: isSet(object.timestampClient)
? fromJsonTimestamp(object.timestampClient)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.message !== undefined && (obj.message = message.message);
message.timestamp !== undefined &&
(obj.timestamp = message.timestamp.toISOString());
message.timestampClient !== undefined &&
(obj.timestampClient = message.timestampClient.toISOString());
return obj;
},
fromPartial(object) {
const message = createBaseLogAnnotationOperatorMessage();
message.message = object.message ?? "";
message.timestamp = object.timestamp ?? undefined;
message.timestampClient = object.timestampClient ?? undefined;
return message;
},
};
function createBaseLogAnnotationLogBlob() {
return {
timestamp: undefined,
channel: "",
typeId: "",
data: new Uint8Array(),
timestampClient: undefined,
};
}
exports.LogAnnotationLogBlob = {
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);
}
if (message.timestampClient !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.timestampClient), writer.uint32(42).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 = createBaseLogAnnotationLogBlob();
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;
case 5:
message.timestampClient = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
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(),
timestampClient: isSet(object.timestampClient)
? fromJsonTimestamp(object.timestampClient)
: undefined,
};
},
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()));
message.timestampClient !== undefined &&
(obj.timestampClient = message.timestampClient.toISOString());
return obj;
},
fromPartial(object) {
const message = createBaseLogAnnotationLogBlob();
message.timestamp = object.timestamp ?? undefined;
message.channel = object.channel ?? "";
message.typeId = object.typeId ?? "";
message.data = object.data ?? new Uint8Array();
message.timestampClient = object.timestampClient ?? undefined;
return message;
},
};
function createBaseAddLogAnnotationResponse() {
return { header: undefined };
}
exports.AddLogAnnotationResponse = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.header !== undefined) {
header_1.ResponseHeader.encode(message.header, writer.uint32(10).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 = createBaseAddLogAnnotationResponse();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.header = header_1.ResponseHeader.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
header: isSet(object.header)
? header_1.ResponseHeader.fromJSON(object.header)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.header !== undefined &&
(obj.header = message.header
? header_1.ResponseHeader.toJSON(message.header)
: undefined);
return obj;
},
fromPartial(object) {
const message = createBaseAddLogAnnotationResponse();
message.header =
object.header !== undefined && object.header !== null
? header_1.ResponseHeader.fromPartial(object.header)
: undefined;
return message;
},
};
var globalThis = (() => {
if (typeof globalThis !== "undefined")
return globalThis;
if (typeof self !== "undefined")
return self;
if (typeof window !== "undefined")
return window;
if (typeof global !== "undefined")
return global;
throw "Unable to locate global object";
})();
function bytesFromBase64(b64) {
if (globalThis.Buffer) {
return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
}
else {
const bin = globalThis.atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
}
function base64FromBytes(arr) {
if (globalThis.Buffer) {
return globalThis.Buffer.from(arr).toString("base64");
}
else {
const bin = [];
arr.forEach((byte) => {
bin.push(String.fromCharCode(byte));
});
return globalThis.btoa(bin.join(""));
}
}
function toTimestamp(date) {
const seconds = date.getTime() / 1000;
const nanos = (date.getTime() % 1000) * 1000000;
return { seconds, nanos };
}
function fromTimestamp(t) {
let millis = t.seconds * 1000;
millis += t.nanos / 1000000;
return new Date(millis);
}
function fromJsonTimestamp(o) {
if (o instanceof Date) {
return o;
}
else if (typeof o === "string") {
return new Date(o);
}
else {
return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
}
}
function isSet(value) {
return value !== null && value !== undefined;
}
//# sourceMappingURL=log_annotation.js.map