spot-sdk-ts/dist/bosdyn/api/robot_id.js

TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.RobotIdResponse = exports.RobotIdRequest = exports.RobotSoftwareRelease = exports.SoftwareVersion = exports.RobotId = exports.protobufPackage = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const parameter_1 = require("./parameter");
const header_1 = require("./header");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
function createBaseRobotId() {
    return {
        serialNumber: "",
        species: "",
        version: "",
        softwareRelease: undefined,
        nickname: "",
        computerSerialNumber: "",
    };
}
exports.RobotId = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.serialNumber !== "") {
            writer.uint32(10).string(message.serialNumber);
        }
        if (message.species !== "") {
            writer.uint32(18).string(message.species);
        }
        if (message.version !== "") {
            writer.uint32(26).string(message.version);
        }
        if (message.softwareRelease !== undefined) {
            exports.RobotSoftwareRelease.encode(message.softwareRelease, writer.uint32(34).fork()).ldelim();
        }
        if (message.nickname !== "") {
            writer.uint32(42).string(message.nickname);
        }
        if (message.computerSerialNumber !== "") {
            writer.uint32(50).string(message.computerSerialNumber);
        }
        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 = createBaseRobotId();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.serialNumber = reader.string();
                    break;
                case 2:
                    message.species = reader.string();
                    break;
                case 3:
                    message.version = reader.string();
                    break;
                case 4:
                    message.softwareRelease = exports.RobotSoftwareRelease.decode(reader, reader.uint32());
                    break;
                case 5:
                    message.nickname = reader.string();
                    break;
                case 6:
                    message.computerSerialNumber = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            serialNumber: isSet(object.serialNumber)
                ? String(object.serialNumber)
                : "",
            species: isSet(object.species) ? String(object.species) : "",
            version: isSet(object.version) ? String(object.version) : "",
            softwareRelease: isSet(object.softwareRelease)
                ? exports.RobotSoftwareRelease.fromJSON(object.softwareRelease)
                : undefined,
            nickname: isSet(object.nickname) ? String(object.nickname) : "",
            computerSerialNumber: isSet(object.computerSerialNumber)
                ? String(object.computerSerialNumber)
                : "",
        };
    },
    toJSON(message) {
        const obj = {};
        message.serialNumber !== undefined &&
            (obj.serialNumber = message.serialNumber);
        message.species !== undefined && (obj.species = message.species);
        message.version !== undefined && (obj.version = message.version);
        message.softwareRelease !== undefined &&
            (obj.softwareRelease = message.softwareRelease
                ? exports.RobotSoftwareRelease.toJSON(message.softwareRelease)
                : undefined);
        message.nickname !== undefined && (obj.nickname = message.nickname);
        message.computerSerialNumber !== undefined &&
            (obj.computerSerialNumber = message.computerSerialNumber);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRobotId();
        message.serialNumber = object.serialNumber ?? "";
        message.species = object.species ?? "";
        message.version = object.version ?? "";
        message.softwareRelease =
            object.softwareRelease !== undefined && object.softwareRelease !== null
                ? exports.RobotSoftwareRelease.fromPartial(object.softwareRelease)
                : undefined;
        message.nickname = object.nickname ?? "";
        message.computerSerialNumber = object.computerSerialNumber ?? "";
        return message;
    },
};
function createBaseSoftwareVersion() {
    return { majorVersion: 0, minorVersion: 0, patchLevel: 0 };
}
exports.SoftwareVersion = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.majorVersion !== 0) {
            writer.uint32(8).int32(message.majorVersion);
        }
        if (message.minorVersion !== 0) {
            writer.uint32(16).int32(message.minorVersion);
        }
        if (message.patchLevel !== 0) {
            writer.uint32(24).int32(message.patchLevel);
        }
        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 = createBaseSoftwareVersion();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.majorVersion = reader.int32();
                    break;
                case 2:
                    message.minorVersion = reader.int32();
                    break;
                case 3:
                    message.patchLevel = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            majorVersion: isSet(object.majorVersion)
                ? Number(object.majorVersion)
                : 0,
            minorVersion: isSet(object.minorVersion)
                ? Number(object.minorVersion)
                : 0,
            patchLevel: isSet(object.patchLevel) ? Number(object.patchLevel) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.majorVersion !== undefined &&
            (obj.majorVersion = Math.round(message.majorVersion));
        message.minorVersion !== undefined &&
            (obj.minorVersion = Math.round(message.minorVersion));
        message.patchLevel !== undefined &&
            (obj.patchLevel = Math.round(message.patchLevel));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSoftwareVersion();
        message.majorVersion = object.majorVersion ?? 0;
        message.minorVersion = object.minorVersion ?? 0;
        message.patchLevel = object.patchLevel ?? 0;
        return message;
    },
};
function createBaseRobotSoftwareRelease() {
    return {
        version: undefined,
        name: "",
        type: "",
        changesetDate: undefined,
        changeset: "",
        apiVersion: "",
        buildInformation: "",
        installDate: undefined,
        parameters: [],
    };
}
exports.RobotSoftwareRelease = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.version !== undefined) {
            exports.SoftwareVersion.encode(message.version, writer.uint32(10).fork()).ldelim();
        }
        if (message.name !== "") {
            writer.uint32(18).string(message.name);
        }
        if (message.type !== "") {
            writer.uint32(26).string(message.type);
        }
        if (message.changesetDate !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.changesetDate), writer.uint32(34).fork()).ldelim();
        }
        if (message.changeset !== "") {
            writer.uint32(42).string(message.changeset);
        }
        if (message.apiVersion !== "") {
            writer.uint32(50).string(message.apiVersion);
        }
        if (message.buildInformation !== "") {
            writer.uint32(58).string(message.buildInformation);
        }
        if (message.installDate !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.installDate), writer.uint32(66).fork()).ldelim();
        }
        for (const v of message.parameters) {
            parameter_1.Parameter.encode(v, writer.uint32(74).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 = createBaseRobotSoftwareRelease();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.version = exports.SoftwareVersion.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.name = reader.string();
                    break;
                case 3:
                    message.type = reader.string();
                    break;
                case 4:
                    message.changesetDate = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 5:
                    message.changeset = reader.string();
                    break;
                case 6:
                    message.apiVersion = reader.string();
                    break;
                case 7:
                    message.buildInformation = reader.string();
                    break;
                case 8:
                    message.installDate = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 9:
                    message.parameters.push(parameter_1.Parameter.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            version: isSet(object.version)
                ? exports.SoftwareVersion.fromJSON(object.version)
                : undefined,
            name: isSet(object.name) ? String(object.name) : "",
            type: isSet(object.type) ? String(object.type) : "",
            changesetDate: isSet(object.changesetDate)
                ? fromJsonTimestamp(object.changesetDate)
                : undefined,
            changeset: isSet(object.changeset) ? String(object.changeset) : "",
            apiVersion: isSet(object.apiVersion) ? String(object.apiVersion) : "",
            buildInformation: isSet(object.buildInformation)
                ? String(object.buildInformation)
                : "",
            installDate: isSet(object.installDate)
                ? fromJsonTimestamp(object.installDate)
                : undefined,
            parameters: Array.isArray(object?.parameters)
                ? object.parameters.map((e) => parameter_1.Parameter.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        message.version !== undefined &&
            (obj.version = message.version
                ? exports.SoftwareVersion.toJSON(message.version)
                : undefined);
        message.name !== undefined && (obj.name = message.name);
        message.type !== undefined && (obj.type = message.type);
        message.changesetDate !== undefined &&
            (obj.changesetDate = message.changesetDate.toISOString());
        message.changeset !== undefined && (obj.changeset = message.changeset);
        message.apiVersion !== undefined && (obj.apiVersion = message.apiVersion);
        message.buildInformation !== undefined &&
            (obj.buildInformation = message.buildInformation);
        message.installDate !== undefined &&
            (obj.installDate = message.installDate.toISOString());
        if (message.parameters) {
            obj.parameters = message.parameters.map((e) => e ? parameter_1.Parameter.toJSON(e) : undefined);
        }
        else {
            obj.parameters = [];
        }
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRobotSoftwareRelease();
        message.version =
            object.version !== undefined && object.version !== null
                ? exports.SoftwareVersion.fromPartial(object.version)
                : undefined;
        message.name = object.name ?? "";
        message.type = object.type ?? "";
        message.changesetDate = object.changesetDate ?? undefined;
        message.changeset = object.changeset ?? "";
        message.apiVersion = object.apiVersion ?? "";
        message.buildInformation = object.buildInformation ?? "";
        message.installDate = object.installDate ?? undefined;
        message.parameters =
            object.parameters?.map((e) => parameter_1.Parameter.fromPartial(e)) || [];
        return message;
    },
};
function createBaseRobotIdRequest() {
    return { header: undefined };
}
exports.RobotIdRequest = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.RequestHeader.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 = createBaseRobotIdRequest();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.header = header_1.RequestHeader.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,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRobotIdRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        return message;
    },
};
function createBaseRobotIdResponse() {
    return { header: undefined, robotId: undefined };
}
exports.RobotIdResponse = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.header !== undefined) {
            header_1.ResponseHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
        }
        if (message.robotId !== undefined) {
            exports.RobotId.encode(message.robotId, 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 = createBaseRobotIdResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.header = header_1.ResponseHeader.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.robotId = exports.RobotId.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,
            robotId: isSet(object.robotId)
                ? exports.RobotId.fromJSON(object.robotId)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.robotId !== undefined &&
            (obj.robotId = message.robotId
                ? exports.RobotId.toJSON(message.robotId)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRobotIdResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.robotId =
            object.robotId !== undefined && object.robotId !== null
                ? exports.RobotId.fromPartial(object.robotId)
                : 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=robot_id.js.map