spot-sdk-ts/dist/bosdyn/api/spot_cam/logging.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.DebugResponse = exports.DebugRequest = exports.SetPassphraseResponse = exports.SetPassphraseRequest = exports.ListLogpointsResponse = exports.ListLogpointsRequest = exports.ListCamerasResponse = exports.ListCamerasRequest = exports.TagResponse = exports.TagRequest = exports.StoreResponse = exports.StoreRequest = exports.RetrieveRawDataResponse = exports.RetrieveRawDataRequest = exports.RetrieveResponse = exports.RetrieveRequest = exports.GetStatusResponse = exports.GetStatusRequest = exports.DeleteResponse = exports.DeleteRequest = exports.Logpoint_Calibration = exports.Logpoint_ImageParams = exports.Logpoint = exports.logpoint_QueueStatusToJSON = exports.logpoint_QueueStatusFromJSON = exports.Logpoint_QueueStatus = exports.logpoint_LogStatusToJSON = exports.logpoint_LogStatusFromJSON = exports.Logpoint_LogStatus = exports.logpoint_RecordTypeToJSON = exports.logpoint_RecordTypeFromJSON = exports.Logpoint_RecordType = exports.protobufPackage = void 0;
/* eslint-disable */
const image_1 = require("../image");
const timestamp_1 = require("../../../google/protobuf/timestamp");
const geometry_1 = require("../geometry");
const camera_1 = require("./camera");
const header_1 = require("../header");
const data_chunk_1 = require("../data_chunk");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api.spot_cam";
/** Possible types of media that can be stored. */
var Logpoint_RecordType;
(function (Logpoint_RecordType) {
    Logpoint_RecordType[Logpoint_RecordType["STILLIMAGE"] = 0] = "STILLIMAGE";
    Logpoint_RecordType[Logpoint_RecordType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Logpoint_RecordType = exports.Logpoint_RecordType || (exports.Logpoint_RecordType = {}));
function logpoint_RecordTypeFromJSON(object) {
    switch (object) {
        case 0:
        case "STILLIMAGE":
            return Logpoint_RecordType.STILLIMAGE;
        case -1:
        case "UNRECOGNIZED":
        default:
            return Logpoint_RecordType.UNRECOGNIZED;
    }
}
exports.logpoint_RecordTypeFromJSON = logpoint_RecordTypeFromJSON;
function logpoint_RecordTypeToJSON(object) {
    switch (object) {
        case Logpoint_RecordType.STILLIMAGE:
            return "STILLIMAGE";
        case Logpoint_RecordType.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.logpoint_RecordTypeToJSON = logpoint_RecordTypeToJSON;
/** Possible stages of data acquisition. */
var Logpoint_LogStatus;
(function (Logpoint_LogStatus) {
    Logpoint_LogStatus[Logpoint_LogStatus["FAILED"] = 0] = "FAILED";
    /** QUEUED - the logpoint has been queued to be downloaded from the renderer */
    Logpoint_LogStatus[Logpoint_LogStatus["QUEUED"] = 1] = "QUEUED";
    /** COMPLETE - the logpoint is written to the disk */
    Logpoint_LogStatus[Logpoint_LogStatus["COMPLETE"] = 2] = "COMPLETE";
    Logpoint_LogStatus[Logpoint_LogStatus["UNKNOWN"] = -1] = "UNKNOWN";
    Logpoint_LogStatus[Logpoint_LogStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Logpoint_LogStatus = exports.Logpoint_LogStatus || (exports.Logpoint_LogStatus = {}));
function logpoint_LogStatusFromJSON(object) {
    switch (object) {
        case 0:
        case "FAILED":
            return Logpoint_LogStatus.FAILED;
        case 1:
        case "QUEUED":
            return Logpoint_LogStatus.QUEUED;
        case 2:
        case "COMPLETE":
            return Logpoint_LogStatus.COMPLETE;
        case -1:
        case "UNKNOWN":
            return Logpoint_LogStatus.UNKNOWN;
        case -1:
        case "UNRECOGNIZED":
        default:
            return Logpoint_LogStatus.UNRECOGNIZED;
    }
}
exports.logpoint_LogStatusFromJSON = logpoint_LogStatusFromJSON;
function logpoint_LogStatusToJSON(object) {
    switch (object) {
        case Logpoint_LogStatus.FAILED:
            return "FAILED";
        case Logpoint_LogStatus.QUEUED:
            return "QUEUED";
        case Logpoint_LogStatus.COMPLETE:
            return "COMPLETE";
        case Logpoint_LogStatus.UNKNOWN:
            return "UNKNOWN";
        case Logpoint_LogStatus.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.logpoint_LogStatusToJSON = logpoint_LogStatusToJSON;
var Logpoint_QueueStatus;
(function (Logpoint_QueueStatus) {
    Logpoint_QueueStatus[Logpoint_QueueStatus["QUEUED_UNKNOWN"] = 0] = "QUEUED_UNKNOWN";
    /** QUEUED_RENDER - The logpoint has been queued to be downloaded from the renderer */
    Logpoint_QueueStatus[Logpoint_QueueStatus["QUEUED_RENDER"] = 1] = "QUEUED_RENDER";
    /** QUEUED_DISK - The logpoint is in general ram, and will be written to the disk when resources allow */
    Logpoint_QueueStatus[Logpoint_QueueStatus["QUEUED_DISK"] = 2] = "QUEUED_DISK";
    Logpoint_QueueStatus[Logpoint_QueueStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Logpoint_QueueStatus = exports.Logpoint_QueueStatus || (exports.Logpoint_QueueStatus = {}));
function logpoint_QueueStatusFromJSON(object) {
    switch (object) {
        case 0:
        case "QUEUED_UNKNOWN":
            return Logpoint_QueueStatus.QUEUED_UNKNOWN;
        case 1:
        case "QUEUED_RENDER":
            return Logpoint_QueueStatus.QUEUED_RENDER;
        case 2:
        case "QUEUED_DISK":
            return Logpoint_QueueStatus.QUEUED_DISK;
        case -1:
        case "UNRECOGNIZED":
        default:
            return Logpoint_QueueStatus.UNRECOGNIZED;
    }
}
exports.logpoint_QueueStatusFromJSON = logpoint_QueueStatusFromJSON;
function logpoint_QueueStatusToJSON(object) {
    switch (object) {
        case Logpoint_QueueStatus.QUEUED_UNKNOWN:
            return "QUEUED_UNKNOWN";
        case Logpoint_QueueStatus.QUEUED_RENDER:
            return "QUEUED_RENDER";
        case Logpoint_QueueStatus.QUEUED_DISK:
            return "QUEUED_DISK";
        case Logpoint_QueueStatus.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.logpoint_QueueStatusToJSON = logpoint_QueueStatusToJSON;
function createBaseLogpoint() {
    return {
        name: "",
        type: 0,
        status: 0,
        queueStatus: 0,
        tag: "",
        timestamp: undefined,
        imageParams: undefined,
        calibration: [],
    };
}
exports.Logpoint = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.name !== "") {
            writer.uint32(10).string(message.name);
        }
        if (message.type !== 0) {
            writer.uint32(16).int32(message.type);
        }
        if (message.status !== 0) {
            writer.uint32(24).int32(message.status);
        }
        if (message.queueStatus !== 0) {
            writer.uint32(64).int32(message.queueStatus);
        }
        if (message.tag !== "") {
            writer.uint32(34).string(message.tag);
        }
        if (message.timestamp !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(42).fork()).ldelim();
        }
        if (message.imageParams !== undefined) {
            exports.Logpoint_ImageParams.encode(message.imageParams, writer.uint32(50).fork()).ldelim();
        }
        for (const v of message.calibration) {
            exports.Logpoint_Calibration.encode(v, writer.uint32(58).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 = createBaseLogpoint();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.name = reader.string();
                    break;
                case 2:
                    message.type = reader.int32();
                    break;
                case 3:
                    message.status = reader.int32();
                    break;
                case 8:
                    message.queueStatus = reader.int32();
                    break;
                case 4:
                    message.tag = reader.string();
                    break;
                case 5:
                    message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 6:
                    message.imageParams = exports.Logpoint_ImageParams.decode(reader, reader.uint32());
                    break;
                case 7:
                    message.calibration.push(exports.Logpoint_Calibration.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            name: isSet(object.name) ? String(object.name) : "",
            type: isSet(object.type) ? logpoint_RecordTypeFromJSON(object.type) : 0,
            status: isSet(object.status)
                ? logpoint_LogStatusFromJSON(object.status)
                : 0,
            queueStatus: isSet(object.queueStatus)
                ? logpoint_QueueStatusFromJSON(object.queueStatus)
                : 0,
            tag: isSet(object.tag) ? String(object.tag) : "",
            timestamp: isSet(object.timestamp)
                ? fromJsonTimestamp(object.timestamp)
                : undefined,
            imageParams: isSet(object.imageParams)
                ? exports.Logpoint_ImageParams.fromJSON(object.imageParams)
                : undefined,
            calibration: Array.isArray(object?.calibration)
                ? object.calibration.map((e) => exports.Logpoint_Calibration.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        message.name !== undefined && (obj.name = message.name);
        message.type !== undefined &&
            (obj.type = logpoint_RecordTypeToJSON(message.type));
        message.status !== undefined &&
            (obj.status = logpoint_LogStatusToJSON(message.status));
        message.queueStatus !== undefined &&
            (obj.queueStatus = logpoint_QueueStatusToJSON(message.queueStatus));
        message.tag !== undefined && (obj.tag = message.tag);
        message.timestamp !== undefined &&
            (obj.timestamp = message.timestamp.toISOString());
        message.imageParams !== undefined &&
            (obj.imageParams = message.imageParams
                ? exports.Logpoint_ImageParams.toJSON(message.imageParams)
                : undefined);
        if (message.calibration) {
            obj.calibration = message.calibration.map((e) => e ? exports.Logpoint_Calibration.toJSON(e) : undefined);
        }
        else {
            obj.calibration = [];
        }
        return obj;
    },
    fromPartial(object) {
        const message = createBaseLogpoint();
        message.name = object.name ?? "";
        message.type = object.type ?? 0;
        message.status = object.status ?? 0;
        message.queueStatus = object.queueStatus ?? 0;
        message.tag = object.tag ?? "";
        message.timestamp = object.timestamp ?? undefined;
        message.imageParams =
            object.imageParams !== undefined && object.imageParams !== null
                ? exports.Logpoint_ImageParams.fromPartial(object.imageParams)
                : undefined;
        message.calibration =
            object.calibration?.map((e) => exports.Logpoint_Calibration.fromPartial(e)) || [];
        return message;
    },
};
function createBaseLogpoint_ImageParams() {
    return { width: 0, height: 0, format: 0 };
}
exports.Logpoint_ImageParams = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.width !== 0) {
            writer.uint32(8).int32(message.width);
        }
        if (message.height !== 0) {
            writer.uint32(16).int32(message.height);
        }
        if (message.format !== 0) {
            writer.uint32(24).int32(message.format);
        }
        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 = createBaseLogpoint_ImageParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.width = reader.int32();
                    break;
                case 2:
                    message.height = reader.int32();
                    break;
                case 3:
                    message.format = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            width: isSet(object.width) ? Number(object.width) : 0,
            height: isSet(object.height) ? Number(object.height) : 0,
            format: isSet(object.format)
                ? (0, image_1.image_PixelFormatFromJSON)(object.format)
                : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.width !== undefined && (obj.width = Math.round(message.width));
        message.height !== undefined && (obj.height = Math.round(message.height));
        message.format !== undefined &&
            (obj.format = (0, image_1.image_PixelFormatToJSON)(message.format));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseLogpoint_ImageParams();
        message.width = object.width ?? 0;
        message.height = object.height ?? 0;
        message.format = object.format ?? 0;
        return message;
    },
};
function createBaseLogpoint_Calibration() {
    return {
        xoffset: 0,
        yoffset: 0,
        width: 0,
        height: 0,
        baseFrameName: "",
        baseTfromSensor: undefined,
        baseTformSensor: undefined,
        intrinsics: undefined,
    };
}
exports.Logpoint_Calibration = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.xoffset !== 0) {
            writer.uint32(8).int32(message.xoffset);
        }
        if (message.yoffset !== 0) {
            writer.uint32(16).int32(message.yoffset);
        }
        if (message.width !== 0) {
            writer.uint32(24).int32(message.width);
        }
        if (message.height !== 0) {
            writer.uint32(32).int32(message.height);
        }
        if (message.baseFrameName !== "") {
            writer.uint32(58).string(message.baseFrameName);
        }
        if (message.baseTfromSensor !== undefined) {
            geometry_1.SE3Pose.encode(message.baseTfromSensor, writer.uint32(42).fork()).ldelim();
        }
        if (message.baseTformSensor !== undefined) {
            geometry_1.SE3Pose.encode(message.baseTformSensor, writer.uint32(66).fork()).ldelim();
        }
        if (message.intrinsics !== undefined) {
            camera_1.Camera_PinholeIntrinsics.encode(message.intrinsics, writer.uint32(50).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 = createBaseLogpoint_Calibration();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.xoffset = reader.int32();
                    break;
                case 2:
                    message.yoffset = reader.int32();
                    break;
                case 3:
                    message.width = reader.int32();
                    break;
                case 4:
                    message.height = reader.int32();
                    break;
                case 7:
                    message.baseFrameName = reader.string();
                    break;
                case 5:
                    message.baseTfromSensor = geometry_1.SE3Pose.decode(reader, reader.uint32());
                    break;
                case 8:
                    message.baseTformSensor = geometry_1.SE3Pose.decode(reader, reader.uint32());
                    break;
                case 6:
                    message.intrinsics = camera_1.Camera_PinholeIntrinsics.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            xoffset: isSet(object.xoffset) ? Number(object.xoffset) : 0,
            yoffset: isSet(object.yoffset) ? Number(object.yoffset) : 0,
            width: isSet(object.width) ? Number(object.width) : 0,
            height: isSet(object.height) ? Number(object.height) : 0,
            baseFrameName: isSet(object.baseFrameName)
                ? String(object.baseFrameName)
                : "",
            baseTfromSensor: isSet(object.baseTfromSensor)
                ? geometry_1.SE3Pose.fromJSON(object.baseTfromSensor)
                : undefined,
            baseTformSensor: isSet(object.baseTformSensor)
                ? geometry_1.SE3Pose.fromJSON(object.baseTformSensor)
                : undefined,
            intrinsics: isSet(object.intrinsics)
                ? camera_1.Camera_PinholeIntrinsics.fromJSON(object.intrinsics)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.xoffset !== undefined &&
            (obj.xoffset = Math.round(message.xoffset));
        message.yoffset !== undefined &&
            (obj.yoffset = Math.round(message.yoffset));
        message.width !== undefined && (obj.width = Math.round(message.width));
        message.height !== undefined && (obj.height = Math.round(message.height));
        message.baseFrameName !== undefined &&
            (obj.baseFrameName = message.baseFrameName);
        message.baseTfromSensor !== undefined &&
            (obj.baseTfromSensor = message.baseTfromSensor
                ? geometry_1.SE3Pose.toJSON(message.baseTfromSensor)
                : undefined);
        message.baseTformSensor !== undefined &&
            (obj.baseTformSensor = message.baseTformSensor
                ? geometry_1.SE3Pose.toJSON(message.baseTformSensor)
                : undefined);
        message.intrinsics !== undefined &&
            (obj.intrinsics = message.intrinsics
                ? camera_1.Camera_PinholeIntrinsics.toJSON(message.intrinsics)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseLogpoint_Calibration();
        message.xoffset = object.xoffset ?? 0;
        message.yoffset = object.yoffset ?? 0;
        message.width = object.width ?? 0;
        message.height = object.height ?? 0;
        message.baseFrameName = object.baseFrameName ?? "";
        message.baseTfromSensor =
            object.baseTfromSensor !== undefined && object.baseTfromSensor !== null
                ? geometry_1.SE3Pose.fromPartial(object.baseTfromSensor)
                : undefined;
        message.baseTformSensor =
            object.baseTformSensor !== undefined && object.baseTformSensor !== null
                ? geometry_1.SE3Pose.fromPartial(object.baseTformSensor)
                : undefined;
        message.intrinsics =
            object.intrinsics !== undefined && object.intrinsics !== null
                ? camera_1.Camera_PinholeIntrinsics.fromPartial(object.intrinsics)
                : undefined;
        return message;
    },
};
function createBaseDeleteRequest() {
    return { header: undefined, point: undefined };
}
exports.DeleteRequest = {
    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.point !== undefined) {
            exports.Logpoint.encode(message.point, 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 = createBaseDeleteRequest();
        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.point = exports.Logpoint.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,
            point: isSet(object.point) ? exports.Logpoint.fromJSON(object.point) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.point !== undefined &&
            (obj.point = message.point ? exports.Logpoint.toJSON(message.point) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseDeleteRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.point =
            object.point !== undefined && object.point !== null
                ? exports.Logpoint.fromPartial(object.point)
                : undefined;
        return message;
    },
};
function createBaseDeleteResponse() {
    return { header: undefined };
}
exports.DeleteResponse = {
    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 = createBaseDeleteResponse();
        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 = createBaseDeleteResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        return message;
    },
};
function createBaseGetStatusRequest() {
    return { header: undefined, point: undefined };
}
exports.GetStatusRequest = {
    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.point !== undefined) {
            exports.Logpoint.encode(message.point, 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 = createBaseGetStatusRequest();
        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.point = exports.Logpoint.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,
            point: isSet(object.point) ? exports.Logpoint.fromJSON(object.point) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.point !== undefined &&
            (obj.point = message.point ? exports.Logpoint.toJSON(message.point) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseGetStatusRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.point =
            object.point !== undefined && object.point !== null
                ? exports.Logpoint.fromPartial(object.point)
                : undefined;
        return message;
    },
};
function createBaseGetStatusResponse() {
    return { header: undefined, point: undefined };
}
exports.GetStatusResponse = {
    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.point !== undefined) {
            exports.Logpoint.encode(message.point, 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 = createBaseGetStatusResponse();
        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.point = exports.Logpoint.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,
            point: isSet(object.point) ? exports.Logpoint.fromJSON(object.point) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.point !== undefined &&
            (obj.point = message.point ? exports.Logpoint.toJSON(message.point) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseGetStatusResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.point =
            object.point !== undefined && object.point !== null
                ? exports.Logpoint.fromPartial(object.point)
                : undefined;
        return message;
    },
};
function createBaseRetrieveRequest() {
    return { header: undefined, point: undefined };
}
exports.RetrieveRequest = {
    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.point !== undefined) {
            exports.Logpoint.encode(message.point, 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 = createBaseRetrieveRequest();
        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.point = exports.Logpoint.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,
            point: isSet(object.point) ? exports.Logpoint.fromJSON(object.point) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.point !== undefined &&
            (obj.point = message.point ? exports.Logpoint.toJSON(message.point) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRetrieveRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.point =
            object.point !== undefined && object.point !== null
                ? exports.Logpoint.fromPartial(object.point)
                : undefined;
        return message;
    },
};
function createBaseRetrieveResponse() {
    return { header: undefined, logpoint: undefined, data: undefined };
}
exports.RetrieveResponse = {
    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.logpoint !== undefined) {
            exports.Logpoint.encode(message.logpoint, writer.uint32(18).fork()).ldelim();
        }
        if (message.data !== undefined) {
            data_chunk_1.DataChunk.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 = createBaseRetrieveResponse();
        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.logpoint = exports.Logpoint.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.data = data_chunk_1.DataChunk.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,
            logpoint: isSet(object.logpoint)
                ? exports.Logpoint.fromJSON(object.logpoint)
                : undefined,
            data: isSet(object.data) ? data_chunk_1.DataChunk.fromJSON(object.data) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.logpoint !== undefined &&
            (obj.logpoint = message.logpoint
                ? exports.Logpoint.toJSON(message.logpoint)
                : undefined);
        message.data !== undefined &&
            (obj.data = message.data ? data_chunk_1.DataChunk.toJSON(message.data) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRetrieveResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.logpoint =
            object.logpoint !== undefined && object.logpoint !== null
                ? exports.Logpoint.fromPartial(object.logpoint)
                : undefined;
        message.data =
            object.data !== undefined && object.data !== null
                ? data_chunk_1.DataChunk.fromPartial(object.data)
                : undefined;
        return message;
    },
};
function createBaseRetrieveRawDataRequest() {
    return { header: undefined, point: undefined };
}
exports.RetrieveRawDataRequest = {
    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.point !== undefined) {
            exports.Logpoint.encode(message.point, 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 = createBaseRetrieveRawDataRequest();
        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.point = exports.Logpoint.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,
            point: isSet(object.point) ? exports.Logpoint.fromJSON(object.point) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.point !== undefined &&
            (obj.point = message.point ? exports.Logpoint.toJSON(message.point) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRetrieveRawDataRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.point =
            object.point !== undefined && object.point !== null
                ? exports.Logpoint.fromPartial(object.point)
                : undefined;
        return message;
    },
};
function createBaseRetrieveRawDataResponse() {
    return { header: undefined, logpoint: undefined, data: undefined };
}
exports.RetrieveRawDataResponse = {
    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.logpoint !== undefined) {
            exports.Logpoint.encode(message.logpoint, writer.uint32(18).fork()).ldelim();
        }
        if (message.data !== undefined) {
            data_chunk_1.DataChunk.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 = createBaseRetrieveRawDataResponse();
        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.logpoint = exports.Logpoint.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.data = data_chunk_1.DataChunk.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,
            logpoint: isSet(object.logpoint)
                ? exports.Logpoint.fromJSON(object.logpoint)
                : undefined,
            data: isSet(object.data) ? data_chunk_1.DataChunk.fromJSON(object.data) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.logpoint !== undefined &&
            (obj.logpoint = message.logpoint
                ? exports.Logpoint.toJSON(message.logpoint)
                : undefined);
        message.data !== undefined &&
            (obj.data = message.data ? data_chunk_1.DataChunk.toJSON(message.data) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseRetrieveRawDataResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.logpoint =
            object.logpoint !== undefined && object.logpoint !== null
                ? exports.Logpoint.fromPartial(object.logpoint)
                : undefined;
        message.data =
            object.data !== undefined && object.data !== null
                ? data_chunk_1.DataChunk.fromPartial(object.data)
                : undefined;
        return message;
    },
};
function createBaseStoreRequest() {
    return { header: undefined, camera: undefined, type: 0, tag: "" };
}
exports.StoreRequest = {
    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.camera !== undefined) {
            camera_1.Camera.encode(message.camera, writer.uint32(18).fork()).ldelim();
        }
        if (message.type !== 0) {
            writer.uint32(24).int32(message.type);
        }
        if (message.tag !== "") {
            writer.uint32(34).string(message.tag);
        }
        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 = createBaseStoreRequest();
        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.camera = camera_1.Camera.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.type = reader.int32();
                    break;
                case 4:
                    message.tag = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.RequestHeader.fromJSON(object.header)
                : undefined,
            camera: isSet(object.camera) ? camera_1.Camera.fromJSON(object.camera) : undefined,
            type: isSet(object.type) ? logpoint_RecordTypeFromJSON(object.type) : 0,
            tag: isSet(object.tag) ? String(object.tag) : "",
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.camera !== undefined &&
            (obj.camera = message.camera ? camera_1.Camera.toJSON(message.camera) : undefined);
        message.type !== undefined &&
            (obj.type = logpoint_RecordTypeToJSON(message.type));
        message.tag !== undefined && (obj.tag = message.tag);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseStoreRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.camera =
            object.camera !== undefined && object.camera !== null
                ? camera_1.Camera.fromPartial(object.camera)
                : undefined;
        message.type = object.type ?? 0;
        message.tag = object.tag ?? "";
        return message;
    },
};
function createBaseStoreResponse() {
    return { header: undefined, point: undefined };
}
exports.StoreResponse = {
    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.point !== undefined) {
            exports.Logpoint.encode(message.point, 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 = createBaseStoreResponse();
        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.point = exports.Logpoint.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,
            point: isSet(object.point) ? exports.Logpoint.fromJSON(object.point) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.point !== undefined &&
            (obj.point = message.point ? exports.Logpoint.toJSON(message.point) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseStoreResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.point =
            object.point !== undefined && object.point !== null
                ? exports.Logpoint.fromPartial(object.point)
                : undefined;
        return message;
    },
};
function createBaseTagRequest() {
    return { header: undefined, point: undefined };
}
exports.TagRequest = {
    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.point !== undefined) {
            exports.Logpoint.encode(message.point, 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 = createBaseTagRequest();
        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.point = exports.Logpoint.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,
            point: isSet(object.point) ? exports.Logpoint.fromJSON(object.point) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.point !== undefined &&
            (obj.point = message.point ? exports.Logpoint.toJSON(message.point) : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseTagRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.point =
            object.point !== undefined && object.point !== null
                ? exports.Logpoint.fromPartial(object.point)
                : undefined;
        return message;
    },
};
function createBaseTagResponse() {
    return { header: undefined };
}
exports.TagResponse = {
    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 = createBaseTagResponse();
        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);