spot-sdk-ts
Version:
TypeScript bindings based on protobufs (proto3) provided by Boston Dynamics
1,243 lines (1,242 loc) • 59.1 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SeriesIdentifier_SpecEntry = exports.SeriesIdentifier = exports.SeriesBlockIndex_BlockEntry = exports.SeriesBlockIndex = exports.FileIndex = exports.StructTypeDescriptor_KeyToSeriesIdentifierHashEntry = exports.StructTypeDescriptor = exports.PodTypeDescriptor = exports.MessageTypeDescriptor = exports.SeriesDescriptor_AnnotationsEntry = exports.SeriesDescriptor = exports.FileFormatVersion = exports.FileFormatDescriptor_AnnotationsEntry = exports.FileFormatDescriptor = exports.DataDescriptor = exports.DescriptorBlock = exports.fileFormatDescriptor_CheckSumTypeToJSON = exports.fileFormatDescriptor_CheckSumTypeFromJSON = exports.FileFormatDescriptor_CheckSumType = exports.podTypeEnumToJSON = exports.podTypeEnumFromJSON = exports.PodTypeEnum = exports.protobufPackage = void 0;
/* eslint-disable */
const timestamp_1 = require("../../google/protobuf/timestamp");
const long_1 = __importDefault(require("long"));
const minimal_1 = __importDefault(require("protobufjs/minimal"));
exports.protobufPackage = "bosdyn.api";
/** "Plain old data" types which may be stored within POD data blocks. */
var PodTypeEnum;
(function (PodTypeEnum) {
PodTypeEnum[PodTypeEnum["TYPE_UNSPECIFIED"] = 0] = "TYPE_UNSPECIFIED";
PodTypeEnum[PodTypeEnum["TYPE_INT8"] = 1] = "TYPE_INT8";
PodTypeEnum[PodTypeEnum["TYPE_INT16"] = 2] = "TYPE_INT16";
PodTypeEnum[PodTypeEnum["TYPE_INT32"] = 3] = "TYPE_INT32";
PodTypeEnum[PodTypeEnum["TYPE_INT64"] = 4] = "TYPE_INT64";
PodTypeEnum[PodTypeEnum["TYPE_UINT8"] = 5] = "TYPE_UINT8";
PodTypeEnum[PodTypeEnum["TYPE_UINT16"] = 6] = "TYPE_UINT16";
PodTypeEnum[PodTypeEnum["TYPE_UINT32"] = 7] = "TYPE_UINT32";
PodTypeEnum[PodTypeEnum["TYPE_UINT64"] = 8] = "TYPE_UINT64";
PodTypeEnum[PodTypeEnum["TYPE_FLOAT32"] = 9] = "TYPE_FLOAT32";
PodTypeEnum[PodTypeEnum["TYPE_FLOAT64"] = 10] = "TYPE_FLOAT64";
PodTypeEnum[PodTypeEnum["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(PodTypeEnum = exports.PodTypeEnum || (exports.PodTypeEnum = {}));
function podTypeEnumFromJSON(object) {
switch (object) {
case 0:
case "TYPE_UNSPECIFIED":
return PodTypeEnum.TYPE_UNSPECIFIED;
case 1:
case "TYPE_INT8":
return PodTypeEnum.TYPE_INT8;
case 2:
case "TYPE_INT16":
return PodTypeEnum.TYPE_INT16;
case 3:
case "TYPE_INT32":
return PodTypeEnum.TYPE_INT32;
case 4:
case "TYPE_INT64":
return PodTypeEnum.TYPE_INT64;
case 5:
case "TYPE_UINT8":
return PodTypeEnum.TYPE_UINT8;
case 6:
case "TYPE_UINT16":
return PodTypeEnum.TYPE_UINT16;
case 7:
case "TYPE_UINT32":
return PodTypeEnum.TYPE_UINT32;
case 8:
case "TYPE_UINT64":
return PodTypeEnum.TYPE_UINT64;
case 9:
case "TYPE_FLOAT32":
return PodTypeEnum.TYPE_FLOAT32;
case 10:
case "TYPE_FLOAT64":
return PodTypeEnum.TYPE_FLOAT64;
case -1:
case "UNRECOGNIZED":
default:
return PodTypeEnum.UNRECOGNIZED;
}
}
exports.podTypeEnumFromJSON = podTypeEnumFromJSON;
function podTypeEnumToJSON(object) {
switch (object) {
case PodTypeEnum.TYPE_UNSPECIFIED:
return "TYPE_UNSPECIFIED";
case PodTypeEnum.TYPE_INT8:
return "TYPE_INT8";
case PodTypeEnum.TYPE_INT16:
return "TYPE_INT16";
case PodTypeEnum.TYPE_INT32:
return "TYPE_INT32";
case PodTypeEnum.TYPE_INT64:
return "TYPE_INT64";
case PodTypeEnum.TYPE_UINT8:
return "TYPE_UINT8";
case PodTypeEnum.TYPE_UINT16:
return "TYPE_UINT16";
case PodTypeEnum.TYPE_UINT32:
return "TYPE_UINT32";
case PodTypeEnum.TYPE_UINT64:
return "TYPE_UINT64";
case PodTypeEnum.TYPE_FLOAT32:
return "TYPE_FLOAT32";
case PodTypeEnum.TYPE_FLOAT64:
return "TYPE_FLOAT64";
case PodTypeEnum.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.podTypeEnumToJSON = podTypeEnumToJSON;
var FileFormatDescriptor_CheckSumType;
(function (FileFormatDescriptor_CheckSumType) {
/** CHECKSUM_TYPE_UNKNOWN - Checksum type is unspecified. Should not be used. */
FileFormatDescriptor_CheckSumType[FileFormatDescriptor_CheckSumType["CHECKSUM_TYPE_UNKNOWN"] = 0] = "CHECKSUM_TYPE_UNKNOWN";
/**
* CHECKSUM_TYPE_NONE - The writer of this stream is not computing a checksum.
* The stream checksum at the end of the file will be 160 bits all set to 0.
*/
FileFormatDescriptor_CheckSumType[FileFormatDescriptor_CheckSumType["CHECKSUM_TYPE_NONE"] = 1] = "CHECKSUM_TYPE_NONE";
/**
* CHECKSUM_TYPE_SHA1 - A 160 bit SHA1 checksum will be included at the end of the stream.
* This checksum will be computed over all data before digest itself at the
* end of the stream, and can be used to verify the stream was received uncorrupted.
*/
FileFormatDescriptor_CheckSumType[FileFormatDescriptor_CheckSumType["CHECKSUM_TYPE_SHA1"] = 2] = "CHECKSUM_TYPE_SHA1";
FileFormatDescriptor_CheckSumType[FileFormatDescriptor_CheckSumType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(FileFormatDescriptor_CheckSumType = exports.FileFormatDescriptor_CheckSumType || (exports.FileFormatDescriptor_CheckSumType = {}));
function fileFormatDescriptor_CheckSumTypeFromJSON(object) {
switch (object) {
case 0:
case "CHECKSUM_TYPE_UNKNOWN":
return FileFormatDescriptor_CheckSumType.CHECKSUM_TYPE_UNKNOWN;
case 1:
case "CHECKSUM_TYPE_NONE":
return FileFormatDescriptor_CheckSumType.CHECKSUM_TYPE_NONE;
case 2:
case "CHECKSUM_TYPE_SHA1":
return FileFormatDescriptor_CheckSumType.CHECKSUM_TYPE_SHA1;
case -1:
case "UNRECOGNIZED":
default:
return FileFormatDescriptor_CheckSumType.UNRECOGNIZED;
}
}
exports.fileFormatDescriptor_CheckSumTypeFromJSON = fileFormatDescriptor_CheckSumTypeFromJSON;
function fileFormatDescriptor_CheckSumTypeToJSON(object) {
switch (object) {
case FileFormatDescriptor_CheckSumType.CHECKSUM_TYPE_UNKNOWN:
return "CHECKSUM_TYPE_UNKNOWN";
case FileFormatDescriptor_CheckSumType.CHECKSUM_TYPE_NONE:
return "CHECKSUM_TYPE_NONE";
case FileFormatDescriptor_CheckSumType.CHECKSUM_TYPE_SHA1:
return "CHECKSUM_TYPE_SHA1";
case FileFormatDescriptor_CheckSumType.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
exports.fileFormatDescriptor_CheckSumTypeToJSON = fileFormatDescriptor_CheckSumTypeToJSON;
function createBaseDescriptorBlock() {
return {
fileDescriptor: undefined,
seriesDescriptor: undefined,
seriesBlockIndex: undefined,
fileIndex: undefined,
};
}
exports.DescriptorBlock = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.fileDescriptor !== undefined) {
exports.FileFormatDescriptor.encode(message.fileDescriptor, writer.uint32(10).fork()).ldelim();
}
if (message.seriesDescriptor !== undefined) {
exports.SeriesDescriptor.encode(message.seriesDescriptor, writer.uint32(18).fork()).ldelim();
}
if (message.seriesBlockIndex !== undefined) {
exports.SeriesBlockIndex.encode(message.seriesBlockIndex, writer.uint32(26).fork()).ldelim();
}
if (message.fileIndex !== undefined) {
exports.FileIndex.encode(message.fileIndex, 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 = createBaseDescriptorBlock();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.fileDescriptor = exports.FileFormatDescriptor.decode(reader, reader.uint32());
break;
case 2:
message.seriesDescriptor = exports.SeriesDescriptor.decode(reader, reader.uint32());
break;
case 3:
message.seriesBlockIndex = exports.SeriesBlockIndex.decode(reader, reader.uint32());
break;
case 4:
message.fileIndex = exports.FileIndex.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
fileDescriptor: isSet(object.fileDescriptor)
? exports.FileFormatDescriptor.fromJSON(object.fileDescriptor)
: undefined,
seriesDescriptor: isSet(object.seriesDescriptor)
? exports.SeriesDescriptor.fromJSON(object.seriesDescriptor)
: undefined,
seriesBlockIndex: isSet(object.seriesBlockIndex)
? exports.SeriesBlockIndex.fromJSON(object.seriesBlockIndex)
: undefined,
fileIndex: isSet(object.fileIndex)
? exports.FileIndex.fromJSON(object.fileIndex)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.fileDescriptor !== undefined &&
(obj.fileDescriptor = message.fileDescriptor
? exports.FileFormatDescriptor.toJSON(message.fileDescriptor)
: undefined);
message.seriesDescriptor !== undefined &&
(obj.seriesDescriptor = message.seriesDescriptor
? exports.SeriesDescriptor.toJSON(message.seriesDescriptor)
: undefined);
message.seriesBlockIndex !== undefined &&
(obj.seriesBlockIndex = message.seriesBlockIndex
? exports.SeriesBlockIndex.toJSON(message.seriesBlockIndex)
: undefined);
message.fileIndex !== undefined &&
(obj.fileIndex = message.fileIndex
? exports.FileIndex.toJSON(message.fileIndex)
: undefined);
return obj;
},
fromPartial(object) {
const message = createBaseDescriptorBlock();
message.fileDescriptor =
object.fileDescriptor !== undefined && object.fileDescriptor !== null
? exports.FileFormatDescriptor.fromPartial(object.fileDescriptor)
: undefined;
message.seriesDescriptor =
object.seriesDescriptor !== undefined && object.seriesDescriptor !== null
? exports.SeriesDescriptor.fromPartial(object.seriesDescriptor)
: undefined;
message.seriesBlockIndex =
object.seriesBlockIndex !== undefined && object.seriesBlockIndex !== null
? exports.SeriesBlockIndex.fromPartial(object.seriesBlockIndex)
: undefined;
message.fileIndex =
object.fileIndex !== undefined && object.fileIndex !== null
? exports.FileIndex.fromPartial(object.fileIndex)
: undefined;
return message;
},
};
function createBaseDataDescriptor() {
return { seriesIndex: 0, timestamp: undefined, additionalIndexes: [] };
}
exports.DataDescriptor = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.seriesIndex !== 0) {
writer.uint32(8).uint32(message.seriesIndex);
}
if (message.timestamp !== undefined) {
timestamp_1.Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(18).fork()).ldelim();
}
writer.uint32(26).fork();
for (const v of message.additionalIndexes) {
writer.int64(v);
}
writer.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 = createBaseDataDescriptor();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.seriesIndex = reader.uint32();
break;
case 2:
message.timestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
break;
case 3:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.additionalIndexes.push(longToNumber(reader.int64()));
}
}
else {
message.additionalIndexes.push(longToNumber(reader.int64()));
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
seriesIndex: isSet(object.seriesIndex) ? Number(object.seriesIndex) : 0,
timestamp: isSet(object.timestamp)
? fromJsonTimestamp(object.timestamp)
: undefined,
additionalIndexes: Array.isArray(object?.additionalIndexes)
? object.additionalIndexes.map((e) => Number(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.seriesIndex !== undefined &&
(obj.seriesIndex = Math.round(message.seriesIndex));
message.timestamp !== undefined &&
(obj.timestamp = message.timestamp.toISOString());
if (message.additionalIndexes) {
obj.additionalIndexes = message.additionalIndexes.map((e) => Math.round(e));
}
else {
obj.additionalIndexes = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseDataDescriptor();
message.seriesIndex = object.seriesIndex ?? 0;
message.timestamp = object.timestamp ?? undefined;
message.additionalIndexes = object.additionalIndexes?.map((e) => e) || [];
return message;
},
};
function createBaseFileFormatDescriptor() {
return {
version: undefined,
annotations: {},
checksumType: 0,
checksumNumBytes: 0,
};
}
exports.FileFormatDescriptor = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.version !== undefined) {
exports.FileFormatVersion.encode(message.version, writer.uint32(10).fork()).ldelim();
}
Object.entries(message.annotations).forEach(([key, value]) => {
exports.FileFormatDescriptor_AnnotationsEntry.encode({ key: key, value }, writer.uint32(18).fork()).ldelim();
});
if (message.checksumType !== 0) {
writer.uint32(24).int32(message.checksumType);
}
if (message.checksumNumBytes !== 0) {
writer.uint32(32).uint32(message.checksumNumBytes);
}
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 = createBaseFileFormatDescriptor();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.version = exports.FileFormatVersion.decode(reader, reader.uint32());
break;
case 2:
const entry2 = exports.FileFormatDescriptor_AnnotationsEntry.decode(reader, reader.uint32());
if (entry2.value !== undefined) {
message.annotations[entry2.key] = entry2.value;
}
break;
case 3:
message.checksumType = reader.int32();
break;
case 4:
message.checksumNumBytes = reader.uint32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
version: isSet(object.version)
? exports.FileFormatVersion.fromJSON(object.version)
: undefined,
annotations: isObject(object.annotations)
? Object.entries(object.annotations).reduce((acc, [key, value]) => {
acc[key] = String(value);
return acc;
}, {})
: {},
checksumType: isSet(object.checksumType)
? fileFormatDescriptor_CheckSumTypeFromJSON(object.checksumType)
: 0,
checksumNumBytes: isSet(object.checksumNumBytes)
? Number(object.checksumNumBytes)
: 0,
};
},
toJSON(message) {
const obj = {};
message.version !== undefined &&
(obj.version = message.version
? exports.FileFormatVersion.toJSON(message.version)
: undefined);
obj.annotations = {};
if (message.annotations) {
Object.entries(message.annotations).forEach(([k, v]) => {
obj.annotations[k] = v;
});
}
message.checksumType !== undefined &&
(obj.checksumType = fileFormatDescriptor_CheckSumTypeToJSON(message.checksumType));
message.checksumNumBytes !== undefined &&
(obj.checksumNumBytes = Math.round(message.checksumNumBytes));
return obj;
},
fromPartial(object) {
const message = createBaseFileFormatDescriptor();
message.version =
object.version !== undefined && object.version !== null
? exports.FileFormatVersion.fromPartial(object.version)
: undefined;
message.annotations = Object.entries(object.annotations ?? {}).reduce((acc, [key, value]) => {
if (value !== undefined) {
acc[key] = String(value);
}
return acc;
}, {});
message.checksumType = object.checksumType ?? 0;
message.checksumNumBytes = object.checksumNumBytes ?? 0;
return message;
},
};
function createBaseFileFormatDescriptor_AnnotationsEntry() {
return { key: "", value: "" };
}
exports.FileFormatDescriptor_AnnotationsEntry = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.key !== "") {
writer.uint32(10).string(message.key);
}
if (message.value !== "") {
writer.uint32(18).string(message.value);
}
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 = createBaseFileFormatDescriptor_AnnotationsEntry();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.string();
break;
case 2:
message.value = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
key: isSet(object.key) ? String(object.key) : "",
value: isSet(object.value) ? String(object.value) : "",
};
},
toJSON(message) {
const obj = {};
message.key !== undefined && (obj.key = message.key);
message.value !== undefined && (obj.value = message.value);
return obj;
},
fromPartial(object) {
const message = createBaseFileFormatDescriptor_AnnotationsEntry();
message.key = object.key ?? "";
message.value = object.value ?? "";
return message;
},
};
function createBaseFileFormatVersion() {
return { majorVersion: 0, minorVersion: 0, patchLevel: 0 };
}
exports.FileFormatVersion = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.majorVersion !== 0) {
writer.uint32(8).uint32(message.majorVersion);
}
if (message.minorVersion !== 0) {
writer.uint32(16).uint32(message.minorVersion);
}
if (message.patchLevel !== 0) {
writer.uint32(24).uint32(message.patchLevel);
}
return writer;
},
decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFileFormatVersion();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.majorVersion = reader.uint32();
break;
case 2:
message.minorVersion = reader.uint32();
break;
case 3:
message.patchLevel = reader.uint32();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
majorVersion: isSet(object.majorVersion)
? Number(object.majorVersion)
: 0,
minorVersion: isSet(object.minorVersion)
? Number(object.minorVersion)
: 0,
patchLevel: isSet(object.patchLevel) ? Number(object.patchLevel) : 0,
};
},
toJSON(message) {
const obj = {};
message.majorVersion !== undefined &&
(obj.majorVersion = Math.round(message.majorVersion));
message.minorVersion !== undefined &&
(obj.minorVersion = Math.round(message.minorVersion));
message.patchLevel !== undefined &&
(obj.patchLevel = Math.round(message.patchLevel));
return obj;
},
fromPartial(object) {
const message = createBaseFileFormatVersion();
message.majorVersion = object.majorVersion ?? 0;
message.minorVersion = object.minorVersion ?? 0;
message.patchLevel = object.patchLevel ?? 0;
return message;
},
};
function createBaseSeriesDescriptor() {
return {
seriesIndex: 0,
seriesIdentifier: undefined,
identifierHash: 0,
messageType: undefined,
podType: undefined,
structType: undefined,
annotations: {},
additionalIndexNames: [],
description: "",
};
}
exports.SeriesDescriptor = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.seriesIndex !== 0) {
writer.uint32(8).uint32(message.seriesIndex);
}
if (message.seriesIdentifier !== undefined) {
exports.SeriesIdentifier.encode(message.seriesIdentifier, writer.uint32(18).fork()).ldelim();
}
if (message.identifierHash !== 0) {
writer.uint32(24).uint64(message.identifierHash);
}
if (message.messageType !== undefined) {
exports.MessageTypeDescriptor.encode(message.messageType, writer.uint32(34).fork()).ldelim();
}
if (message.podType !== undefined) {
exports.PodTypeDescriptor.encode(message.podType, writer.uint32(42).fork()).ldelim();
}
if (message.structType !== undefined) {
exports.StructTypeDescriptor.encode(message.structType, writer.uint32(50).fork()).ldelim();
}
Object.entries(message.annotations).forEach(([key, value]) => {
exports.SeriesDescriptor_AnnotationsEntry.encode({ key: key, value }, writer.uint32(58).fork()).ldelim();
});
for (const v of message.additionalIndexNames) {
writer.uint32(66).string(v);
}
if (message.description !== "") {
writer.uint32(74).string(message.description);
}
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 = createBaseSeriesDescriptor();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.seriesIndex = reader.uint32();
break;
case 2:
message.seriesIdentifier = exports.SeriesIdentifier.decode(reader, reader.uint32());
break;
case 3:
message.identifierHash = longToNumber(reader.uint64());
break;
case 4:
message.messageType = exports.MessageTypeDescriptor.decode(reader, reader.uint32());
break;
case 5:
message.podType = exports.PodTypeDescriptor.decode(reader, reader.uint32());
break;
case 6:
message.structType = exports.StructTypeDescriptor.decode(reader, reader.uint32());
break;
case 7:
const entry7 = exports.SeriesDescriptor_AnnotationsEntry.decode(reader, reader.uint32());
if (entry7.value !== undefined) {
message.annotations[entry7.key] = entry7.value;
}
break;
case 8:
message.additionalIndexNames.push(reader.string());
break;
case 9:
message.description = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
seriesIndex: isSet(object.seriesIndex) ? Number(object.seriesIndex) : 0,
seriesIdentifier: isSet(object.seriesIdentifier)
? exports.SeriesIdentifier.fromJSON(object.seriesIdentifier)
: undefined,
identifierHash: isSet(object.identifierHash)
? Number(object.identifierHash)
: 0,
messageType: isSet(object.messageType)
? exports.MessageTypeDescriptor.fromJSON(object.messageType)
: undefined,
podType: isSet(object.podType)
? exports.PodTypeDescriptor.fromJSON(object.podType)
: undefined,
structType: isSet(object.structType)
? exports.StructTypeDescriptor.fromJSON(object.structType)
: undefined,
annotations: isObject(object.annotations)
? Object.entries(object.annotations).reduce((acc, [key, value]) => {
acc[key] = String(value);
return acc;
}, {})
: {},
additionalIndexNames: Array.isArray(object?.additionalIndexNames)
? object.additionalIndexNames.map((e) => String(e))
: [],
description: isSet(object.description) ? String(object.description) : "",
};
},
toJSON(message) {
const obj = {};
message.seriesIndex !== undefined &&
(obj.seriesIndex = Math.round(message.seriesIndex));
message.seriesIdentifier !== undefined &&
(obj.seriesIdentifier = message.seriesIdentifier
? exports.SeriesIdentifier.toJSON(message.seriesIdentifier)
: undefined);
message.identifierHash !== undefined &&
(obj.identifierHash = Math.round(message.identifierHash));
message.messageType !== undefined &&
(obj.messageType = message.messageType
? exports.MessageTypeDescriptor.toJSON(message.messageType)
: undefined);
message.podType !== undefined &&
(obj.podType = message.podType
? exports.PodTypeDescriptor.toJSON(message.podType)
: undefined);
message.structType !== undefined &&
(obj.structType = message.structType
? exports.StructTypeDescriptor.toJSON(message.structType)
: undefined);
obj.annotations = {};
if (message.annotations) {
Object.entries(message.annotations).forEach(([k, v]) => {
obj.annotations[k] = v;
});
}
if (message.additionalIndexNames) {
obj.additionalIndexNames = message.additionalIndexNames.map((e) => e);
}
else {
obj.additionalIndexNames = [];
}
message.description !== undefined &&
(obj.description = message.description);
return obj;
},
fromPartial(object) {
const message = createBaseSeriesDescriptor();
message.seriesIndex = object.seriesIndex ?? 0;
message.seriesIdentifier =
object.seriesIdentifier !== undefined && object.seriesIdentifier !== null
? exports.SeriesIdentifier.fromPartial(object.seriesIdentifier)
: undefined;
message.identifierHash = object.identifierHash ?? 0;
message.messageType =
object.messageType !== undefined && object.messageType !== null
? exports.MessageTypeDescriptor.fromPartial(object.messageType)
: undefined;
message.podType =
object.podType !== undefined && object.podType !== null
? exports.PodTypeDescriptor.fromPartial(object.podType)
: undefined;
message.structType =
object.structType !== undefined && object.structType !== null
? exports.StructTypeDescriptor.fromPartial(object.structType)
: undefined;
message.annotations = Object.entries(object.annotations ?? {}).reduce((acc, [key, value]) => {
if (value !== undefined) {
acc[key] = String(value);
}
return acc;
}, {});
message.additionalIndexNames =
object.additionalIndexNames?.map((e) => e) || [];
message.description = object.description ?? "";
return message;
},
};
function createBaseSeriesDescriptor_AnnotationsEntry() {
return { key: "", value: "" };
}
exports.SeriesDescriptor_AnnotationsEntry = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.key !== "") {
writer.uint32(10).string(message.key);
}
if (message.value !== "") {
writer.uint32(18).string(message.value);
}
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 = createBaseSeriesDescriptor_AnnotationsEntry();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.string();
break;
case 2:
message.value = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
key: isSet(object.key) ? String(object.key) : "",
value: isSet(object.value) ? String(object.value) : "",
};
},
toJSON(message) {
const obj = {};
message.key !== undefined && (obj.key = message.key);
message.value !== undefined && (obj.value = message.value);
return obj;
},
fromPartial(object) {
const message = createBaseSeriesDescriptor_AnnotationsEntry();
message.key = object.key ?? "";
message.value = object.value ?? "";
return message;
},
};
function createBaseMessageTypeDescriptor() {
return { contentType: "", typeName: "", isMetadata: false };
}
exports.MessageTypeDescriptor = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.contentType !== "") {
writer.uint32(10).string(message.contentType);
}
if (message.typeName !== "") {
writer.uint32(18).string(message.typeName);
}
if (message.isMetadata === true) {
writer.uint32(24).bool(message.isMetadata);
}
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 = createBaseMessageTypeDescriptor();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.contentType = reader.string();
break;
case 2:
message.typeName = reader.string();
break;
case 3:
message.isMetadata = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
contentType: isSet(object.contentType) ? String(object.contentType) : "",
typeName: isSet(object.typeName) ? String(object.typeName) : "",
isMetadata: isSet(object.isMetadata) ? Boolean(object.isMetadata) : false,
};
},
toJSON(message) {
const obj = {};
message.contentType !== undefined &&
(obj.contentType = message.contentType);
message.typeName !== undefined && (obj.typeName = message.typeName);
message.isMetadata !== undefined && (obj.isMetadata = message.isMetadata);
return obj;
},
fromPartial(object) {
const message = createBaseMessageTypeDescriptor();
message.contentType = object.contentType ?? "";
message.typeName = object.typeName ?? "";
message.isMetadata = object.isMetadata ?? false;
return message;
},
};
function createBasePodTypeDescriptor() {
return { podType: 0, dimension: [] };
}
exports.PodTypeDescriptor = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.podType !== 0) {
writer.uint32(8).int32(message.podType);
}
writer.uint32(18).fork();
for (const v of message.dimension) {
writer.uint32(v);
}
writer.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 = createBasePodTypeDescriptor();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.podType = reader.int32();
break;
case 2:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.dimension.push(reader.uint32());
}
}
else {
message.dimension.push(reader.uint32());
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
podType: isSet(object.podType) ? podTypeEnumFromJSON(object.podType) : 0,
dimension: Array.isArray(object?.dimension)
? object.dimension.map((e) => Number(e))
: [],
};
},
toJSON(message) {
const obj = {};
message.podType !== undefined &&
(obj.podType = podTypeEnumToJSON(message.podType));
if (message.dimension) {
obj.dimension = message.dimension.map((e) => Math.round(e));
}
else {
obj.dimension = [];
}
return obj;
},
fromPartial(object) {
const message = createBasePodTypeDescriptor();
message.podType = object.podType ?? 0;
message.dimension = object.dimension?.map((e) => e) || [];
return message;
},
};
function createBaseStructTypeDescriptor() {
return { keyToSeriesIdentifierHash: {} };
}
exports.StructTypeDescriptor = {
encode(message, writer = minimal_1.default.Writer.create()) {
Object.entries(message.keyToSeriesIdentifierHash).forEach(([key, value]) => {
exports.StructTypeDescriptor_KeyToSeriesIdentifierHashEntry.encode({ key: key, value }, 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 = createBaseStructTypeDescriptor();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
const entry1 = exports.StructTypeDescriptor_KeyToSeriesIdentifierHashEntry.decode(reader, reader.uint32());
if (entry1.value !== undefined) {
message.keyToSeriesIdentifierHash[entry1.key] = entry1.value;
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
keyToSeriesIdentifierHash: isObject(object.keyToSeriesIdentifierHash)
? Object.entries(object.keyToSeriesIdentifierHash).reduce((acc, [key, value]) => {
acc[key] = Number(value);
return acc;
}, {})
: {},
};
},
toJSON(message) {
const obj = {};
obj.keyToSeriesIdentifierHash = {};
if (message.keyToSeriesIdentifierHash) {
Object.entries(message.keyToSeriesIdentifierHash).forEach(([k, v]) => {
obj.keyToSeriesIdentifierHash[k] = Math.round(v);
});
}
return obj;
},
fromPartial(object) {
const message = createBaseStructTypeDescriptor();
message.keyToSeriesIdentifierHash = Object.entries(object.keyToSeriesIdentifierHash ?? {}).reduce((acc, [key, value]) => {
if (value !== undefined) {
acc[key] = Number(value);
}
return acc;
}, {});
return message;
},
};
function createBaseStructTypeDescriptor_KeyToSeriesIdentifierHashEntry() {
return { key: "", value: 0 };
}
exports.StructTypeDescriptor_KeyToSeriesIdentifierHashEntry = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.key !== "") {
writer.uint32(10).string(message.key);
}
if (message.value !== 0) {
writer.uint32(16).uint64(message.value);
}
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 = createBaseStructTypeDescriptor_KeyToSeriesIdentifierHashEntry();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.string();
break;
case 2:
message.value = longToNumber(reader.uint64());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
key: isSet(object.key) ? String(object.key) : "",
value: isSet(object.value) ? Number(object.value) : 0,
};
},
toJSON(message) {
const obj = {};
message.key !== undefined && (obj.key = message.key);
message.value !== undefined && (obj.value = Math.round(message.value));
return obj;
},
fromPartial(object) {
const message = createBaseStructTypeDescriptor_KeyToSeriesIdentifierHashEntry();
message.key = object.key ?? "";
message.value = object.value ?? 0;
return message;
},
};
function createBaseFileIndex() {
return {
seriesIdentifiers: [],
seriesBlockIndexOffsets: [],
seriesIdentifierHashes: [],
};
}
exports.FileIndex = {
encode(message, writer = minimal_1.default.Writer.create()) {
for (const v of message.seriesIdentifiers) {
exports.SeriesIdentifier.encode(v, writer.uint32(10).fork()).ldelim();
}
writer.uint32(18).fork();
for (const v of message.seriesBlockIndexOffsets) {
writer.uint64(v);
}
writer.ldelim();
writer.uint32(26).fork();
for (const v of message.seriesIdentifierHashes) {
writer.uint64(v);
}
writer.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 = createBaseFileIndex();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.seriesIdentifiers.push(exports.SeriesIdentifier.decode(reader, reader.uint32()));
break;
case 2:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.seriesBlockIndexOffsets.push(longToNumber(reader.uint64()));
}
}
else {
message.seriesBlockIndexOffsets.push(longToNumber(reader.uint64()));
}
break;
case 3:
if ((tag & 7) === 2) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.seriesIdentifierHashes.push(longToNumber(reader.uint64()));
}
}
else {
message.seriesIdentifierHashes.push(longToNumber(reader.uint64()));
}
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
seriesIdentifiers: Array.isArray(object?.seriesIdentifiers)
? object.seriesIdentifiers.map((e) => exports.SeriesIdentifier.fromJSON(e))
: [],
seriesBlockIndexOffsets: Array.isArray(object?.seriesBlockIndexOffsets)
? object.seriesBlockIndexOffsets.map((e) => Number(e))
: [],
seriesIdentifierHashes: Array.isArray(object?.seriesIdentifierHashes)
? object.seriesIdentifierHashes.map((e) => Number(e))
: [],
};
},
toJSON(message) {
const obj = {};
if (message.seriesIdentifiers) {
obj.seriesIdentifiers = message.seriesIdentifiers.map((e) => e ? exports.SeriesIdentifier.toJSON(e) : undefined);
}
else {
obj.seriesIdentifiers = [];
}
if (message.seriesBlockIndexOffsets) {
obj.seriesBlockIndexOffsets = message.seriesBlockIndexOffsets.map((e) => Math.round(e));
}
else {
obj.seriesBlockIndexOffsets = [];
}
if (message.seriesIdentifierHashes) {
obj.seriesIdentifierHashes = message.seriesIdentifierHashes.map((e) => Math.round(e));
}
else {
obj.seriesIdentifierHashes = [];
}
return obj;
},
fromPartial(object) {
const message = createBaseFileIndex();
message.seriesIdentifiers =
object.seriesIdentifiers?.map((e) => exports.SeriesIdentifier.fromPartial(e)) ||
[];
message.seriesBlockIndexOffsets =
object.seriesBlockIndexOffsets?.map((e) => e) || [];
message.seriesIdentifierHashes =
object.seriesIdentifierHashes?.map((e) => e) || [];
return message;
},
};
function createBaseSeriesBlockIndex() {
return {
seriesIndex: 0,
descriptorFileOffset: 0,
blockEntries: [],
totalBytes: 0,
};
}
exports.SeriesBlockIndex = {
encode(message, writer = minimal_1.default.Writer.create()) {
if (message.seriesIndex !== 0) {
writer.uint32(8).uint32(message.seriesIndex);
}
if (message.descriptorFileOffset !== 0) {
writer.uint32(16).uint64(message.descriptorFileOffset);
}
for (const v of message.blockEntries) {
exports.SeriesBlockIndex_BlockEntry.encode(v, writer.uint32(26).fork()).ldelim();
}
if (message.totalBytes !== 0) {
writer.uint32(32).uint64(message.totalBytes);
}
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 = createBaseSeriesBlockIndex();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.seriesIndex = reader.uint32();
break;
case 2:
message.descriptorFileOffset = longToNumber(reader.uint64());
break;
case 3:
message.blockEntries.push(exports.SeriesBlockIndex_BlockEntry.decode(reader, reader.uint32()));
break;
case 4:
message.totalBytes = longToNumber(reader.uint64());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
seriesIndex: isSet(object.seriesIndex) ? Number(object.seriesIndex) : 0,
descriptorFileOffset: isSet(object.descriptorFileOffset)
? Number(object.descriptorFileOffset)
: 0,
blockEntries: Array.isArray(object?.blockEntries)
? object.blockEntries.map((e) => exports.SeriesBlockIndex_BlockEntry.fromJSON(e))
: [],
totalBytes: isSet(object.totalBytes) ? Number(object.totalBytes) : 0,
};
},
toJSON(message) {
const obj = {};
message.seriesIndex !== undefined &&
(obj.seriesIndex = Math.round(message.seriesIndex));
message.descriptorFileOffset !== undefined &&
(obj.descriptorFileOffset = Math.round(message.descriptorFileOffset));
if (message.blockEntries) {
obj.blockEntries = message.blockEntries.map((e) => e ? exports.SeriesBlockIndex_BlockEntry.toJSON(e) : undefined);
}
else {
obj.blockEntries = [];
}
message.totalBytes !== undefined &&
(obj.totalBytes = Math.round(message.totalBytes));
return obj;
},
fromPartial(object) {
const message = createBaseSeriesBlockIndex();
message.seriesIndex = object.seriesIndex ?? 0;
message.descriptorFileOffset = object.descriptorFileOffset ?? 0;
message.blockEntries =