spot-sdk-ts/dist/bosdyn/api/spot_cam/streamquality.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.EnableCongestionControlResponse = exports.EnableCongestionControlRequest = exports.SetStreamParamsResponse = exports.SetStreamParamsRequest = exports.GetStreamParamsResponse = exports.GetStreamParamsRequest = exports.StreamParams_AwbMode = exports.StreamParams = exports.streamParams_AwbModeEnumToJSON = exports.streamParams_AwbModeEnumFromJSON = exports.StreamParams_AwbModeEnum = exports.protobufPackage = void 0;
/* eslint-disable */
const header_1 = require("../header");
const minimal_1 = __importDefault(require("protobufjs/minimal"));
const wrappers_1 = require("../../../google/protobuf/wrappers");
exports.protobufPackage = "bosdyn.api.spot_cam";
/** Options for automatic white balancing mode. */
var StreamParams_AwbModeEnum;
(function (StreamParams_AwbModeEnum) {
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["OFF"] = 0] = "OFF";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["AUTO"] = 1] = "AUTO";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["INCANDESCENT"] = 2] = "INCANDESCENT";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["FLUORESCENT"] = 3] = "FLUORESCENT";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["WARM_FLUORESCENT"] = 4] = "WARM_FLUORESCENT";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["DAYLIGHT"] = 5] = "DAYLIGHT";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["CLOUDY"] = 6] = "CLOUDY";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["TWILIGHT"] = 7] = "TWILIGHT";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["SHADE"] = 8] = "SHADE";
    /** @deprecated */
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["DARK"] = 9] = "DARK";
    StreamParams_AwbModeEnum[StreamParams_AwbModeEnum["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(StreamParams_AwbModeEnum = exports.StreamParams_AwbModeEnum || (exports.StreamParams_AwbModeEnum = {}));
function streamParams_AwbModeEnumFromJSON(object) {
    switch (object) {
        case 0:
        case "OFF":
            return StreamParams_AwbModeEnum.OFF;
        case 1:
        case "AUTO":
            return StreamParams_AwbModeEnum.AUTO;
        case 2:
        case "INCANDESCENT":
            return StreamParams_AwbModeEnum.INCANDESCENT;
        case 3:
        case "FLUORESCENT":
            return StreamParams_AwbModeEnum.FLUORESCENT;
        case 4:
        case "WARM_FLUORESCENT":
            return StreamParams_AwbModeEnum.WARM_FLUORESCENT;
        case 5:
        case "DAYLIGHT":
            return StreamParams_AwbModeEnum.DAYLIGHT;
        case 6:
        case "CLOUDY":
            return StreamParams_AwbModeEnum.CLOUDY;
        case 7:
        case "TWILIGHT":
            return StreamParams_AwbModeEnum.TWILIGHT;
        case 8:
        case "SHADE":
            return StreamParams_AwbModeEnum.SHADE;
        case 9:
        case "DARK":
            return StreamParams_AwbModeEnum.DARK;
        case -1:
        case "UNRECOGNIZED":
        default:
            return StreamParams_AwbModeEnum.UNRECOGNIZED;
    }
}
exports.streamParams_AwbModeEnumFromJSON = streamParams_AwbModeEnumFromJSON;
function streamParams_AwbModeEnumToJSON(object) {
    switch (object) {
        case StreamParams_AwbModeEnum.OFF:
            return "OFF";
        case StreamParams_AwbModeEnum.AUTO:
            return "AUTO";
        case StreamParams_AwbModeEnum.INCANDESCENT:
            return "INCANDESCENT";
        case StreamParams_AwbModeEnum.FLUORESCENT:
            return "FLUORESCENT";
        case StreamParams_AwbModeEnum.WARM_FLUORESCENT:
            return "WARM_FLUORESCENT";
        case StreamParams_AwbModeEnum.DAYLIGHT:
            return "DAYLIGHT";
        case StreamParams_AwbModeEnum.CLOUDY:
            return "CLOUDY";
        case StreamParams_AwbModeEnum.TWILIGHT:
            return "TWILIGHT";
        case StreamParams_AwbModeEnum.SHADE:
            return "SHADE";
        case StreamParams_AwbModeEnum.DARK:
            return "DARK";
        case StreamParams_AwbModeEnum.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.streamParams_AwbModeEnumToJSON = streamParams_AwbModeEnumToJSON;
function createBaseStreamParams() {
    return {
        targetbitrate: undefined,
        refreshinterval: undefined,
        idrinterval: undefined,
        awb: undefined,
    };
}
exports.StreamParams = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.targetbitrate !== undefined) {
            wrappers_1.Int64Value.encode({ value: message.targetbitrate }, writer.uint32(10).fork()).ldelim();
        }
        if (message.refreshinterval !== undefined) {
            wrappers_1.Int64Value.encode({ value: message.refreshinterval }, writer.uint32(18).fork()).ldelim();
        }
        if (message.idrinterval !== undefined) {
            wrappers_1.Int64Value.encode({ value: message.idrinterval }, writer.uint32(26).fork()).ldelim();
        }
        if (message.awb !== undefined) {
            exports.StreamParams_AwbMode.encode(message.awb, 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 = createBaseStreamParams();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.targetbitrate = wrappers_1.Int64Value.decode(reader, reader.uint32()).value;
                    break;
                case 2:
                    message.refreshinterval = wrappers_1.Int64Value.decode(reader, reader.uint32()).value;
                    break;
                case 3:
                    message.idrinterval = wrappers_1.Int64Value.decode(reader, reader.uint32()).value;
                    break;
                case 4:
                    message.awb = exports.StreamParams_AwbMode.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            targetbitrate: isSet(object.targetbitrate)
                ? Number(object.targetbitrate)
                : undefined,
            refreshinterval: isSet(object.refreshinterval)
                ? Number(object.refreshinterval)
                : undefined,
            idrinterval: isSet(object.idrinterval)
                ? Number(object.idrinterval)
                : undefined,
            awb: isSet(object.awb)
                ? exports.StreamParams_AwbMode.fromJSON(object.awb)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.targetbitrate !== undefined &&
            (obj.targetbitrate = message.targetbitrate);
        message.refreshinterval !== undefined &&
            (obj.refreshinterval = message.refreshinterval);
        message.idrinterval !== undefined &&
            (obj.idrinterval = message.idrinterval);
        message.awb !== undefined &&
            (obj.awb = message.awb
                ? exports.StreamParams_AwbMode.toJSON(message.awb)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseStreamParams();
        message.targetbitrate = object.targetbitrate ?? undefined;
        message.refreshinterval = object.refreshinterval ?? undefined;
        message.idrinterval = object.idrinterval ?? undefined;
        message.awb =
            object.awb !== undefined && object.awb !== null
                ? exports.StreamParams_AwbMode.fromPartial(object.awb)
                : undefined;
        return message;
    },
};
function createBaseStreamParams_AwbMode() {
    return { awb: 0 };
}
exports.StreamParams_AwbMode = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.awb !== 0) {
            writer.uint32(8).int32(message.awb);
        }
        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 = createBaseStreamParams_AwbMode();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.awb = reader.int32();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            awb: isSet(object.awb) ? streamParams_AwbModeEnumFromJSON(object.awb) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        message.awb !== undefined &&
            (obj.awb = streamParams_AwbModeEnumToJSON(message.awb));
        return obj;
    },
    fromPartial(object) {
        const message = createBaseStreamParams_AwbMode();
        message.awb = object.awb ?? 0;
        return message;
    },
};
function createBaseGetStreamParamsRequest() {
    return { header: undefined };
}
exports.GetStreamParamsRequest = {
    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 = createBaseGetStreamParamsRequest();
        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 = createBaseGetStreamParamsRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        return message;
    },
};
function createBaseGetStreamParamsResponse() {
    return { header: undefined, params: undefined };
}
exports.GetStreamParamsResponse = {
    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.params !== undefined) {
            exports.StreamParams.encode(message.params, 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 = createBaseGetStreamParamsResponse();
        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.params = exports.StreamParams.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,
            params: isSet(object.params)
                ? exports.StreamParams.fromJSON(object.params)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.params !== undefined &&
            (obj.params = message.params
                ? exports.StreamParams.toJSON(message.params)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseGetStreamParamsResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.params =
            object.params !== undefined && object.params !== null
                ? exports.StreamParams.fromPartial(object.params)
                : undefined;
        return message;
    },
};
function createBaseSetStreamParamsRequest() {
    return { header: undefined, params: undefined };
}
exports.SetStreamParamsRequest = {
    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.params !== undefined) {
            exports.StreamParams.encode(message.params, 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 = createBaseSetStreamParamsRequest();
        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.params = exports.StreamParams.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,
            params: isSet(object.params)
                ? exports.StreamParams.fromJSON(object.params)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.params !== undefined &&
            (obj.params = message.params
                ? exports.StreamParams.toJSON(message.params)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSetStreamParamsRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.params =
            object.params !== undefined && object.params !== null
                ? exports.StreamParams.fromPartial(object.params)
                : undefined;
        return message;
    },
};
function createBaseSetStreamParamsResponse() {
    return { header: undefined, params: undefined };
}
exports.SetStreamParamsResponse = {
    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.params !== undefined) {
            exports.StreamParams.encode(message.params, 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 = createBaseSetStreamParamsResponse();
        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.params = exports.StreamParams.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,
            params: isSet(object.params)
                ? exports.StreamParams.fromJSON(object.params)
                : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.ResponseHeader.toJSON(message.header)
                : undefined);
        message.params !== undefined &&
            (obj.params = message.params
                ? exports.StreamParams.toJSON(message.params)
                : undefined);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseSetStreamParamsResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        message.params =
            object.params !== undefined && object.params !== null
                ? exports.StreamParams.fromPartial(object.params)
                : undefined;
        return message;
    },
};
function createBaseEnableCongestionControlRequest() {
    return { header: undefined, enableCongestionControl: false };
}
exports.EnableCongestionControlRequest = {
    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.enableCongestionControl === true) {
            writer.uint32(16).bool(message.enableCongestionControl);
        }
        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 = createBaseEnableCongestionControlRequest();
        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.enableCongestionControl = reader.bool();
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            header: isSet(object.header)
                ? header_1.RequestHeader.fromJSON(object.header)
                : undefined,
            enableCongestionControl: isSet(object.enableCongestionControl)
                ? Boolean(object.enableCongestionControl)
                : false,
        };
    },
    toJSON(message) {
        const obj = {};
        message.header !== undefined &&
            (obj.header = message.header
                ? header_1.RequestHeader.toJSON(message.header)
                : undefined);
        message.enableCongestionControl !== undefined &&
            (obj.enableCongestionControl = message.enableCongestionControl);
        return obj;
    },
    fromPartial(object) {
        const message = createBaseEnableCongestionControlRequest();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.RequestHeader.fromPartial(object.header)
                : undefined;
        message.enableCongestionControl = object.enableCongestionControl ?? false;
        return message;
    },
};
function createBaseEnableCongestionControlResponse() {
    return { header: undefined };
}
exports.EnableCongestionControlResponse = {
    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 = createBaseEnableCongestionControlResponse();
        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 = createBaseEnableCongestionControlResponse();
        message.header =
            object.header !== undefined && object.header !== null
                ? header_1.ResponseHeader.fromPartial(object.header)
                : undefined;
        return message;
    },
};
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=streamquality.js.map