spot-sdk-ts/dist/bosdyn/api/time_sync.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.TimeSyncUpdateResponse = exports.TimeSyncUpdateRequest = exports.TimeSyncState = exports.TimeSyncEstimate = exports.TimeSyncRoundTrip = exports.timeSyncState_StatusToJSON = exports.timeSyncState_StatusFromJSON = exports.TimeSyncState_Status = exports.protobufPackage = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const duration_1 = require("../../google/protobuf/duration");
const header_1 = require("./header");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
var TimeSyncState_Status;
(function (TimeSyncState_Status) {
    /** STATUS_UNKNOWN - Invalid, do not use. */
    TimeSyncState_Status[TimeSyncState_Status["STATUS_UNKNOWN"] = 0] = "STATUS_UNKNOWN";
    /** STATUS_OK - Clock skew is available. */
    TimeSyncState_Status[TimeSyncState_Status["STATUS_OK"] = 1] = "STATUS_OK";
    /** STATUS_MORE_SAMPLES_NEEDED - More updates are required to establish a synchronization estimate. */
    TimeSyncState_Status[TimeSyncState_Status["STATUS_MORE_SAMPLES_NEEDED"] = 2] = "STATUS_MORE_SAMPLES_NEEDED";
    /** STATUS_SERVICE_NOT_READY - Server still establishing time sync internally. */
    TimeSyncState_Status[TimeSyncState_Status["STATUS_SERVICE_NOT_READY"] = 3] = "STATUS_SERVICE_NOT_READY";
    TimeSyncState_Status[TimeSyncState_Status["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(TimeSyncState_Status = exports.TimeSyncState_Status || (exports.TimeSyncState_Status = {}));
function timeSyncState_StatusFromJSON(object) {
    switch (object) {
        case 0:
        case "STATUS_UNKNOWN":
            return TimeSyncState_Status.STATUS_UNKNOWN;
        case 1:
        case "STATUS_OK":
            return TimeSyncState_Status.STATUS_OK;
        case 2:
        case "STATUS_MORE_SAMPLES_NEEDED":
            return TimeSyncState_Status.STATUS_MORE_SAMPLES_NEEDED;
        case 3:
        case "STATUS_SERVICE_NOT_READY":
            return TimeSyncState_Status.STATUS_SERVICE_NOT_READY;
        case -1:
        case "UNRECOGNIZED":
        default:
            return TimeSyncState_Status.UNRECOGNIZED;
    }
}
exports.timeSyncState_StatusFromJSON = timeSyncState_StatusFromJSON;
function timeSyncState_StatusToJSON(object) {
    switch (object) {
        case TimeSyncState_Status.STATUS_UNKNOWN:
            return "STATUS_UNKNOWN";
        case TimeSyncState_Status.STATUS_OK:
            return "STATUS_OK";
        case TimeSyncState_Status.STATUS_MORE_SAMPLES_NEEDED:
            return "STATUS_MORE_SAMPLES_NEEDED";
        case TimeSyncState_Status.STATUS_SERVICE_NOT_READY:
            return "STATUS_SERVICE_NOT_READY";
        case TimeSyncState_Status.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.timeSyncState_StatusToJSON = timeSyncState_StatusToJSON;
function createBaseTimeSyncRoundTrip() {
    return {
        clientTx: undefined,
        serverRx: undefined,
        serverTx: undefined,
        clientRx: undefined,
    };
}
exports.TimeSyncRoundTrip = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.clientTx !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.clientTx), writer.uint32(10).fork()).ldelim();
        }
        if (message.serverRx !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.serverRx), writer.uint32(18).fork()).ldelim();
        }
        if (message.serverTx !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.serverTx), writer.uint32(26).fork()).ldelim();
        }
        if (message.clientRx !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.clientRx), writer.uint32(34).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 = createBaseTimeSyncRoundTrip();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.clientTx = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 2:
                    message.serverRx = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.serverTx = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 4:
                    message.clientRx = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            clientTx: isSet(object.clientTx)
                ? fromJsonTimestamp(object.clientTx)
                : undefined,
            serverRx: isSet(object.serverRx)
                ? fromJsonTimestamp(object.serverRx)
                : undefined,
            serverTx: isSet(object.serverTx)
                ? fromJsonTimestamp(object.serverTx)
                : undefined,
            clientRx: isSet(object.clientRx)
                ? fromJsonTimestamp(object.clientRx)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.clientTx !== undefined &&
            (obj.clientTx = message.clientTx.toISOString());
        message.serverRx !== undefined &&
            (obj.serverRx = message.serverRx.toISOString());
        message.serverTx !== undefined &&
            (obj.serverTx = message.serverTx.toISOString());
        message.clientRx !== undefined &&
            (obj.clientRx = message.clientRx.toISOString());
        return obj;
    },
    fromPartial(object) {
        const message = createBaseTimeSyncRoundTrip();
        message.clientTx = object.clientTx ?? undefined;
        message.serverRx = object.serverRx ?? undefined;
        message.serverTx = object.serverTx ?? undefined;
        message.clientRx = object.clientRx ?? undefined;
        return message;
    },
};
function createBaseTimeSyncEstimate() {
    return { roundTripTime: undefined, clockSkew: undefined };
}
exports.TimeSyncEstimate = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.roundTripTime !== undefined) {
            duration_1.Duration.encode(message.roundTripTime, writer.uint32(10).fork()).ldelim();
        }
        if (message.clockSkew !== undefined) {
            duration_1.Duration.encode(message.clockSkew, 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 = createBaseTimeSyncEstimate();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.roundTripTime = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.clockSkew = duration_1.Duration.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            roundTripTime: isSet(object.roundTripTime)
                ? duration_1.Duration.fromJSON(object.roundTripTime)
                : undefined,
            clockSkew: isSet(object.clockSkew)
                ? duration_1.Duration.fromJSON(object.clockSkew)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.roundTripTime !== undefined &&
            (obj.roundTripTime = message.roundTripTime
                ? duration_1.Duration.toJSON(message.roundTripTime)
                : undefined);
        message.clockSkew !== undefined &&
            (obj.clockSkew = message.clockSkew
                ? duration_1.Duration.toJSON(message.clockSkew)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseTimeSyncEstimate();
        message.roundTripTime =
            object.roundTripTime !== undefined && object.roundTripTime !== null
                ? duration_1.Duration.fromPartial(object.roundTripTime)
                : undefined;
        message.clockSkew =
            object.clockSkew !== undefined && object.clockSkew !== null
                ? duration_1.Duration.fromPartial(object.clockSkew)
                : undefined;
        return message;
    },
};
function createBaseTimeSyncState() {
    return { bestEstimate: undefined, status: 0, measurementTime: undefined };
}
exports.TimeSyncState = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.bestEstimate !== undefined) {
            exports.TimeSyncEstimate.encode(message.bestEstimate, writer.uint32(10).fork()).ldelim();
        }
        if (message.status !== 0) {
            writer.uint32(16).int32(message.status);
        }
        if (message.measurementTime !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.measurementTime), 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 = createBaseTimeSyncState();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.bestEstimate = exports.TimeSyncEstimate.decode(reader, reader.uint32());
                    break;
                case 2:
                    message.status = reader.int32();
                    break;
                case 3:
                    message.measurementTime = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            bestEstimate: isSet(object.bestEstimate)
                ? exports.TimeSyncEstimate.fromJSON(object.bestEstimate)
                : undefined,
            status: isSet(object.status)
                ? timeSyncState_StatusFromJSON(object.status)
                : 0,
            measurementTime: isSet(object.measurementTime)
                ? fromJsonTimestamp(object.measurementTime)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.bestEstimate !== undefined &&
            (obj.bestEstimate = message.bestEstimate
                ? exports.TimeSyncEstimate.toJSON(message.bestEstimate)
                : undefined);
        message.status !== undefined &&
            (obj.status = timeSyncState_StatusToJSON(message.status));
        message.measurementTime !== undefined &&
            (obj.measurementTime = message.measurementTime.toISOString());
        return obj;
    },
    fromPartial(object) {
        const message = createBaseTimeSyncState();
        message.bestEstimate =
            object.bestEstimate !== undefined && object.bestEstimate !== null
                ? exports.TimeSyncEstimate.fromPartial(object.bestEstimate)
                : undefined;
        message.status = object.status ?? 0;
        message.measurementTime = object.measurementTime ?? undefined;
        return message;
    },
};
function createBaseTimeSyncUpdateRequest() {
    return {
        header: undefined,
        previousRoundTrip: undefined,
        clockIdentifier: "",
    };
}
exports.TimeSyncUpdateRequest = {
    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.previousRoundTrip !== undefined) {
            exports.TimeSyncRoundTrip.encode(message.previousRoundTrip, writer.uint32(18).fork()).ldelim();
        }
        if (message.clockIdentifier !== "") {
            writer.uint32(26).string(message.clockIdentifier);
        }
        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 = createBaseTimeSyncUpdateRequest();
        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.previousRoundTrip = exports.TimeSyncRoundTrip.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.clockIdentifier = 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,
            previousRoundTrip: isSet(object.previousRoundTrip)
                ? exports.TimeSyncRoundTrip.fromJSON(object.previousRoundTrip)
                : undefined,
            clockIdentifier: isSet(object.clockIdentifier)
                ? String(object.clockIdentifier)
                : "",
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.previousRoundTrip !== undefined &&
            (obj.previousRoundTrip = message.previousRoundTrip
                ? exports.TimeSyncRoundTrip.toJSON(message.previousRoundTrip)
                : undefined);
        message.clockIdentifier !== undefined &&
            (obj.clockIdentifier = message.clockIdentifier);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseTimeSyncUpdateRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.previousRoundTrip =
            object.previousRoundTrip !== undefined &&
                object.previousRoundTrip !== null
                ? exports.TimeSyncRoundTrip.fromPartial(object.previousRoundTrip)
                : undefined;
        message.clockIdentifier = object.clockIdentifier ?? "";
        return message;
    },
};
function createBaseTimeSyncUpdateResponse() {
    return {
        header: undefined,
        previousEstimate: undefined,
        state: undefined,
        clockIdentifier: "",
    };
}
exports.TimeSyncUpdateResponse = {
    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.previousEstimate !== undefined) {
            exports.TimeSyncEstimate.encode(message.previousEstimate, writer.uint32(18).fork()).ldelim();
        }
        if (message.state !== undefined) {
            exports.TimeSyncState.encode(message.state, writer.uint32(26).fork()).ldelim();
        }
        if (message.clockIdentifier !== "") {
            writer.uint32(34).string(message.clockIdentifier);
        }
        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 = createBaseTimeSyncUpdateResponse();
        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.previousEstimate = exports.TimeSyncEstimate.decode(reader, reader.uint32());
                    break;
                case 3:
                    message.state = exports.TimeSyncState.decode(reader, reader.uint32());
                    break;
                case 4:
                    message.clockIdentifier = reader.string();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.ResponseHeader.fromJSON(object.header)
                : undefined,
            previousEstimate: isSet(object.previousEstimate)
                ? exports.TimeSyncEstimate.fromJSON(object.previousEstimate)
                : undefined,
            state: isSet(object.state)
                ? exports.TimeSyncState.fromJSON(object.state)
                : undefined,
            clockIdentifier: isSet(object.clockIdentifier)
                ? String(object.clockIdentifier)
                : "",
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.previousEstimate !== undefined &&
            (obj.previousEstimate = message.previousEstimate
                ? exports.TimeSyncEstimate.toJSON(message.previousEstimate)
                : undefined);
        message.state !== undefined &&
            (obj.state = message.state
                ? exports.TimeSyncState.toJSON(message.state)
                : undefined);
        message.clockIdentifier !== undefined &&
            (obj.clockIdentifier = message.clockIdentifier);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseTimeSyncUpdateResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.previousEstimate =
            object.previousEstimate !== undefined && object.previousEstimate !== null
                ? exports.TimeSyncEstimate.fromPartial(object.previousEstimate)
                : undefined;
        message.state =
            object.state !== undefined && object.state !== null
                ? exports.TimeSyncState.fromPartial(object.state)
                : undefined;
        message.clockIdentifier = object.clockIdentifier ?? "";
        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=time_sync.js.map