spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
335 lines • 13.6 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResponseHeader = exports.CommonError = exports.RequestHeader = exports.commonError_CodeToJSON = exports.commonError_CodeFromJSON = exports.CommonError_Code = exports.protobufPackage = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const any_1 = require("../../google/protobuf/any");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
var CommonError_Code;
(function (CommonError_Code) {
/** CODE_UNSPECIFIED - Code is not specified. */
CommonError_Code[CommonError_Code["CODE_UNSPECIFIED"] = 0] = "CODE_UNSPECIFIED";
/** CODE_OK - Not an error. Request was successful. */
CommonError_Code[CommonError_Code["CODE_OK"] = 1] = "CODE_OK";
/** CODE_INTERNAL_SERVER_ERROR - Service experienced an unexpected error state. */
CommonError_Code[CommonError_Code["CODE_INTERNAL_SERVER_ERROR"] = 2] = "CODE_INTERNAL_SERVER_ERROR";
/** CODE_INVALID_REQUEST - Ill-formed request. Request arguments were not valid. */
CommonError_Code[CommonError_Code["CODE_INVALID_REQUEST"] = 3] = "CODE_INVALID_REQUEST";
CommonError_Code[CommonError_Code["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(CommonError_Code = exports.CommonError_Code || (exports.CommonError_Code = {}));
function commonError_CodeFromJSON(object) {
switch (object) {
case 0:
case "CODE_UNSPECIFIED":
return CommonError_Code.CODE_UNSPECIFIED;
case 1:
case "CODE_OK":
return CommonError_Code.CODE_OK;
case 2:
case "CODE_INTERNAL_SERVER_ERROR":
return CommonError_Code.CODE_INTERNAL_SERVER_ERROR;
case 3:
case "CODE_INVALID_REQUEST":
return CommonError_Code.CODE_INVALID_REQUEST;
case -1:
case "UNRECOGNIZED":
default:
return CommonError_Code.UNRECOGNIZED;
}
}
exports.commonError_CodeFromJSON = commonError_CodeFromJSON;
function commonError_CodeToJSON(object) {
switch (object) {
case CommonError_Code.CODE_UNSPECIFIED:
return "CODE_UNSPECIFIED";
case CommonError_Code.CODE_OK:
return "CODE_OK";
case CommonError_Code.CODE_INTERNAL_SERVER_ERROR:
return "CODE_INTERNAL_SERVER_ERROR";
case CommonError_Code.CODE_INVALID_REQUEST:
return "CODE_INVALID_REQUEST";
case CommonError_Code.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.commonError_CodeToJSON = commonError_CodeToJSON;
function createBaseRequestHeader() {
return {
requestTimestamp: undefined,
clientName: "",
disableRpcLogging: false,
};
}
exports.RequestHeader = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.requestTimestamp !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.requestTimestamp), writer.uint32(10).fork()).ldelim();
}
if (message.clientName !== "") {
writer.uint32(18).string(message.clientName);
}
if (message.disableRpcLogging === true) {
writer.uint32(24).bool(message.disableRpcLogging);
}
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 = createBaseRequestHeader();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.requestTimestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
break;
case 2:
message.clientName = reader.string();
break;
case 3:
message.disableRpcLogging = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
requestTimestamp: isSet(object.requestTimestamp)
? fromJsonTimestamp(object.requestTimestamp)
: undefined,
clientName: isSet(object.clientName) ? String(object.clientName) : "",
disableRpcLogging: isSet(object.disableRpcLogging)
? Boolean(object.disableRpcLogging)
: false,
};
},
toJSON(message) {
const obj = {};
message.requestTimestamp !== undefined &&
(obj.requestTimestamp = message.requestTimestamp.toISOString());
message.clientName !== undefined && (obj.clientName = message.clientName);
message.disableRpcLogging !== undefined &&
(obj.disableRpcLogging = message.disableRpcLogging);
return obj;
},
fromPartial(object) {
const message = createBaseRequestHeader();
message.requestTimestamp = object.requestTimestamp ?? undefined;
message.clientName = object.clientName ?? "";
message.disableRpcLogging = object.disableRpcLogging ?? false;
return message;
},
};
function createBaseCommonError() {
return { code: 0, message: "", data: undefined };
}
exports.CommonError = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.code !== 0) {
writer.uint32(8).int32(message.code);
}
if (message.message !== "") {
writer.uint32(18).string(message.message);
}
if (message.data !== undefined) {
any_1.Any.encode(message.data, 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 = createBaseCommonError();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.code = reader.int32();
break;
case 2:
message.message = reader.string();
break;
case 3:
message.data = any_1.Any.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
code: isSet(object.code) ? commonError_CodeFromJSON(object.code) : 0,
message: isSet(object.message) ? String(object.message) : "",
data: isSet(object.data) ? any_1.Any.fromJSON(object.data) : undefined,
};
},
toJSON(message) {
const obj = {};
message.code !== undefined &&
(obj.code = commonError_CodeToJSON(message.code));
message.message !== undefined && (obj.message = message.message);
message.data !== undefined &&
(obj.data = message.data ? any_1.Any.toJSON(message.data) : undefined);
return obj;
},
fromPartial(object) {
const message = createBaseCommonError();
message.code = object.code ?? 0;
message.message = object.message ?? "";
message.data =
object.data !== undefined && object.data !== null
? any_1.Any.fromPartial(object.data)
: undefined;
return message;
},
};
function createBaseResponseHeader() {
return {
requestHeader: undefined,
requestReceivedTimestamp: undefined,
responseTimestamp: undefined,
error: undefined,
request: undefined,
};
}
exports.ResponseHeader = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.requestHeader !== undefined) {
exports.RequestHeader.encode(message.requestHeader, writer.uint32(10).fork()).ldelim();
}
if (message.requestReceivedTimestamp !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.requestReceivedTimestamp), writer.uint32(18).fork()).ldelim();
}
if (message.responseTimestamp !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.responseTimestamp), writer.uint32(26).fork()).ldelim();
}
if (message.error !== undefined) {
exports.CommonError.encode(message.error, writer.uint32(34).fork()).ldelim();
}
if (message.request !== undefined) {
any_1.Any.encode(message.request, 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 = createBaseResponseHeader();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.requestHeader = exports.RequestHeader.decode(reader, reader.uint32());
break;
case 2:
message.requestReceivedTimestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
break;
case 3:
message.responseTimestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
break;
case 4:
message.error = exports.CommonError.decode(reader, reader.uint32());
break;
case 5:
message.request = any_1.Any.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
requestHeader: isSet(object.requestHeader)
? exports.RequestHeader.fromJSON(object.requestHeader)
: undefined,
requestReceivedTimestamp: isSet(object.requestReceivedTimestamp)
? fromJsonTimestamp(object.requestReceivedTimestamp)
: undefined,
responseTimestamp: isSet(object.responseTimestamp)
? fromJsonTimestamp(object.responseTimestamp)
: undefined,
error: isSet(object.error)
? exports.CommonError.fromJSON(object.error)
: undefined,
request: isSet(object.request) ? any_1.Any.fromJSON(object.request) : undefined,
};
},
toJSON(message) {
const obj = {};
message.requestHeader !== undefined &&
(obj.requestHeader = message.requestHeader
? exports.RequestHeader.toJSON(message.requestHeader)
: undefined);
message.requestReceivedTimestamp !== undefined &&
(obj.requestReceivedTimestamp =
message.requestReceivedTimestamp.toISOString());
message.responseTimestamp !== undefined &&
(obj.responseTimestamp = message.responseTimestamp.toISOString());
message.error !== undefined &&
(obj.error = message.error
? exports.CommonError.toJSON(message.error)
: undefined);
message.request !== undefined &&
(obj.request = message.request ? any_1.Any.toJSON(message.request) : undefined);
return obj;
},
fromPartial(object) {
const message = createBaseResponseHeader();
message.requestHeader =
object.requestHeader !== undefined && object.requestHeader !== null
? exports.RequestHeader.fromPartial(object.requestHeader)
: undefined;
message.requestReceivedTimestamp =
object.requestReceivedTimestamp ?? undefined;
message.responseTimestamp = object.responseTimestamp ?? undefined;
message.error =
object.error !== undefined && object.error !== null
? exports.CommonError.fromPartial(object.error)
: undefined;
message.request =
object.request !== undefined && object.request !== null
? any_1.Any.fromPartial(object.request)
: undefined;
return message;
},
};
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=header.js.map