@mapeo/schema
Version:
JSON schema and flow types for Mapeo
573 lines (572 loc) • 24.7 kB
JavaScript
/* eslint-disable */
import _m0 from "protobufjs/minimal.js";
import { Struct } from "../google/protobuf/struct.js";
import { Timestamp } from "../google/protobuf/timestamp.js";
export const protobufPackage = "mapeo";
function createBaseObservation_4() {
return {
id: Buffer.alloc(0),
created_at: undefined,
timestamp: undefined,
userId: undefined,
deviceId: undefined,
links: [],
lat: undefined,
lon: undefined,
refs: [],
attachments: [],
tags: undefined,
metadata: undefined,
};
}
export const Observation_4 = {
encode(message, writer = _m0.Writer.create()) {
if (message.id.length !== 0) {
writer.uint32(10).bytes(message.id);
}
if (message.created_at !== undefined) {
Timestamp.encode(toTimestamp(message.created_at), writer.uint32(34).fork()).ldelim();
}
if (message.timestamp !== undefined) {
Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(42).fork()).ldelim();
}
if (message.userId !== undefined) {
writer.uint32(50).string(message.userId);
}
if (message.deviceId !== undefined) {
writer.uint32(58).string(message.deviceId);
}
for (const v of message.links) {
writer.uint32(66).string(v);
}
if (message.lat !== undefined) {
writer.uint32(77).float(message.lat);
}
if (message.lon !== undefined) {
writer.uint32(85).float(message.lon);
}
for (const v of message.refs) {
Struct.encode(Struct.wrap(v), writer.uint32(90).fork()).ldelim();
}
for (const v of message.attachments) {
Struct.encode(Struct.wrap(v), writer.uint32(98).fork()).ldelim();
}
if (message.tags !== undefined) {
Struct.encode(Struct.wrap(message.tags), writer.uint32(106).fork()).ldelim();
}
if (message.metadata !== undefined) {
Observation_4_Metadata.encode(message.metadata, writer.uint32(114).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseObservation_4();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.id = reader.bytes();
break;
case 4:
message.created_at = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
break;
case 5:
message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
break;
case 6:
message.userId = reader.string();
break;
case 7:
message.deviceId = reader.string();
break;
case 8:
message.links.push(reader.string());
break;
case 9:
message.lat = reader.float();
break;
case 10:
message.lon = reader.float();
break;
case 11:
message.refs.push(Struct.unwrap(Struct.decode(reader, reader.uint32())));
break;
case 12:
message.attachments.push(Struct.unwrap(Struct.decode(reader, reader.uint32())));
break;
case 13:
message.tags = Struct.unwrap(Struct.decode(reader, reader.uint32()));
break;
case 14:
message.metadata = Observation_4_Metadata.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
id: isSet(object.id) ? Buffer.from(bytesFromBase64(object.id)) : Buffer.alloc(0),
created_at: isSet(object.created_at) ? fromJsonTimestamp(object.created_at) : undefined,
timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
userId: isSet(object.userId) ? String(object.userId) : undefined,
deviceId: isSet(object.deviceId) ? String(object.deviceId) : undefined,
links: Array.isArray(object === null || object === void 0 ? void 0 : object.links) ? object.links.map((e) => String(e)) : [],
lat: isSet(object.lat) ? Number(object.lat) : undefined,
lon: isSet(object.lon) ? Number(object.lon) : undefined,
refs: Array.isArray(object === null || object === void 0 ? void 0 : object.refs) ? [...object.refs] : [],
attachments: Array.isArray(object === null || object === void 0 ? void 0 : object.attachments) ? [...object.attachments] : [],
tags: isObject(object.tags) ? object.tags : undefined,
metadata: isSet(object.metadata) ? Observation_4_Metadata.fromJSON(object.metadata) : undefined,
};
},
toJSON(message) {
const obj = {};
message.id !== undefined && (obj.id = base64FromBytes(message.id !== undefined ? message.id : Buffer.alloc(0)));
message.created_at !== undefined && (obj.created_at = message.created_at.toISOString());
message.timestamp !== undefined && (obj.timestamp = message.timestamp.toISOString());
message.userId !== undefined && (obj.userId = message.userId);
message.deviceId !== undefined && (obj.deviceId = message.deviceId);
if (message.links) {
obj.links = message.links.map((e) => e);
}
else {
obj.links = [];
}
message.lat !== undefined && (obj.lat = message.lat);
message.lon !== undefined && (obj.lon = message.lon);
if (message.refs) {
obj.refs = message.refs.map((e) => e);
}
else {
obj.refs = [];
}
if (message.attachments) {
obj.attachments = message.attachments.map((e) => e);
}
else {
obj.attachments = [];
}
message.tags !== undefined && (obj.tags = message.tags);
message.metadata !== undefined &&
(obj.metadata = message.metadata ? Observation_4_Metadata.toJSON(message.metadata) : undefined);
return obj;
},
create(base) {
return Observation_4.fromPartial(base !== null && base !== void 0 ? base : {});
},
fromPartial(object) {
var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
const message = createBaseObservation_4();
message.id = (_a = object.id) !== null && _a !== void 0 ? _a : Buffer.alloc(0);
message.created_at = (_b = object.created_at) !== null && _b !== void 0 ? _b : undefined;
message.timestamp = (_c = object.timestamp) !== null && _c !== void 0 ? _c : undefined;
message.userId = (_d = object.userId) !== null && _d !== void 0 ? _d : undefined;
message.deviceId = (_e = object.deviceId) !== null && _e !== void 0 ? _e : undefined;
message.links = ((_f = object.links) === null || _f === void 0 ? void 0 : _f.map((e) => e)) || [];
message.lat = (_g = object.lat) !== null && _g !== void 0 ? _g : undefined;
message.lon = (_h = object.lon) !== null && _h !== void 0 ? _h : undefined;
message.refs = ((_j = object.refs) === null || _j === void 0 ? void 0 : _j.map((e) => e)) || [];
message.attachments = ((_k = object.attachments) === null || _k === void 0 ? void 0 : _k.map((e) => e)) || [];
message.tags = (_l = object.tags) !== null && _l !== void 0 ? _l : undefined;
message.metadata = (object.metadata !== undefined && object.metadata !== null)
? Observation_4_Metadata.fromPartial(object.metadata)
: undefined;
return message;
},
};
function createBaseObservation_4_Metadata() {
return { manual_location: undefined, position: undefined, lastSavedPosition: undefined, positionProvider: undefined };
}
export const Observation_4_Metadata = {
encode(message, writer = _m0.Writer.create()) {
if (message.manual_location !== undefined) {
writer.uint32(8).bool(message.manual_location);
}
if (message.position !== undefined) {
Observation_4_Metadata_Position.encode(message.position, writer.uint32(26).fork()).ldelim();
}
if (message.lastSavedPosition !== undefined) {
Observation_4_Metadata_Position.encode(message.lastSavedPosition, writer.uint32(34).fork()).ldelim();
}
if (message.positionProvider !== undefined) {
Observation_4_Metadata_PositionProvider.encode(message.positionProvider, writer.uint32(42).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseObservation_4_Metadata();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.manual_location = reader.bool();
break;
case 3:
message.position = Observation_4_Metadata_Position.decode(reader, reader.uint32());
break;
case 4:
message.lastSavedPosition = Observation_4_Metadata_Position.decode(reader, reader.uint32());
break;
case 5:
message.positionProvider = Observation_4_Metadata_PositionProvider.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
manual_location: isSet(object.manual_location) ? Boolean(object.manual_location) : undefined,
position: isSet(object.position) ? Observation_4_Metadata_Position.fromJSON(object.position) : undefined,
lastSavedPosition: isSet(object.lastSavedPosition)
? Observation_4_Metadata_Position.fromJSON(object.lastSavedPosition)
: undefined,
positionProvider: isSet(object.positionProvider)
? Observation_4_Metadata_PositionProvider.fromJSON(object.positionProvider)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.manual_location !== undefined && (obj.manual_location = message.manual_location);
message.position !== undefined &&
(obj.position = message.position ? Observation_4_Metadata_Position.toJSON(message.position) : undefined);
message.lastSavedPosition !== undefined && (obj.lastSavedPosition = message.lastSavedPosition
? Observation_4_Metadata_Position.toJSON(message.lastSavedPosition)
: undefined);
message.positionProvider !== undefined && (obj.positionProvider = message.positionProvider
? Observation_4_Metadata_PositionProvider.toJSON(message.positionProvider)
: undefined);
return obj;
},
create(base) {
return Observation_4_Metadata.fromPartial(base !== null && base !== void 0 ? base : {});
},
fromPartial(object) {
var _a;
const message = createBaseObservation_4_Metadata();
message.manual_location = (_a = object.manual_location) !== null && _a !== void 0 ? _a : undefined;
message.position = (object.position !== undefined && object.position !== null)
? Observation_4_Metadata_Position.fromPartial(object.position)
: undefined;
message.lastSavedPosition = (object.lastSavedPosition !== undefined && object.lastSavedPosition !== null)
? Observation_4_Metadata_Position.fromPartial(object.lastSavedPosition)
: undefined;
message.positionProvider = (object.positionProvider !== undefined && object.positionProvider !== null)
? Observation_4_Metadata_PositionProvider.fromPartial(object.positionProvider)
: undefined;
return message;
},
};
function createBaseObservation_4_Metadata_Position() {
return { timestamp: 0, mocked: false, coords: undefined };
}
export const Observation_4_Metadata_Position = {
encode(message, writer = _m0.Writer.create()) {
if (message.timestamp !== 0) {
writer.uint32(13).float(message.timestamp);
}
if (message.mocked === true) {
writer.uint32(16).bool(message.mocked);
}
if (message.coords !== undefined) {
Observation_4_Metadata_Position_Coords.encode(message.coords, writer.uint32(26).fork()).ldelim();
}
return writer;
},
decode(input, length) {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseObservation_4_Metadata_Position();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.timestamp = reader.float();
break;
case 2:
message.mocked = reader.bool();
break;
case 3:
message.coords = Observation_4_Metadata_Position_Coords.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
timestamp: isSet(object.timestamp) ? Number(object.timestamp) : 0,
mocked: isSet(object.mocked) ? Boolean(object.mocked) : false,
coords: isSet(object.coords) ? Observation_4_Metadata_Position_Coords.fromJSON(object.coords) : undefined,
};
},
toJSON(message) {
const obj = {};
message.timestamp !== undefined && (obj.timestamp = message.timestamp);
message.mocked !== undefined && (obj.mocked = message.mocked);
message.coords !== undefined &&
(obj.coords = message.coords ? Observation_4_Metadata_Position_Coords.toJSON(message.coords) : undefined);
return obj;
},
create(base) {
return Observation_4_Metadata_Position.fromPartial(base !== null && base !== void 0 ? base : {});
},
fromPartial(object) {
var _a, _b;
const message = createBaseObservation_4_Metadata_Position();
message.timestamp = (_a = object.timestamp) !== null && _a !== void 0 ? _a : 0;
message.mocked = (_b = object.mocked) !== null && _b !== void 0 ? _b : false;
message.coords = (object.coords !== undefined && object.coords !== null)
? Observation_4_Metadata_Position_Coords.fromPartial(object.coords)
: undefined;
return message;
},
};
function createBaseObservation_4_Metadata_Position_Coords() {
return { altitude: 0, heading: 0, longitude: 0, latitude: 0, speed: 0, acurracy: 0 };
}
export const Observation_4_Metadata_Position_Coords = {
encode(message, writer = _m0.Writer.create()) {
if (message.altitude !== 0) {
writer.uint32(13).float(message.altitude);
}
if (message.heading !== 0) {
writer.uint32(21).float(message.heading);
}
if (message.longitude !== 0) {
writer.uint32(29).float(message.longitude);
}
if (message.latitude !== 0) {
writer.uint32(37).float(message.latitude);
}
if (message.speed !== 0) {
writer.uint32(45).float(message.speed);
}
if (message.acurracy !== 0) {
writer.uint32(53).float(message.acurracy);
}
return writer;
},
decode(input, length) {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseObservation_4_Metadata_Position_Coords();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.altitude = reader.float();
break;
case 2:
message.heading = reader.float();
break;
case 3:
message.longitude = reader.float();
break;
case 4:
message.latitude = reader.float();
break;
case 5:
message.speed = reader.float();
break;
case 6:
message.acurracy = reader.float();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
altitude: isSet(object.altitude) ? Number(object.altitude) : 0,
heading: isSet(object.heading) ? Number(object.heading) : 0,
longitude: isSet(object.longitude) ? Number(object.longitude) : 0,
latitude: isSet(object.latitude) ? Number(object.latitude) : 0,
speed: isSet(object.speed) ? Number(object.speed) : 0,
acurracy: isSet(object.acurracy) ? Number(object.acurracy) : 0,
};
},
toJSON(message) {
const obj = {};
message.altitude !== undefined && (obj.altitude = message.altitude);
message.heading !== undefined && (obj.heading = message.heading);
message.longitude !== undefined && (obj.longitude = message.longitude);
message.latitude !== undefined && (obj.latitude = message.latitude);
message.speed !== undefined && (obj.speed = message.speed);
message.acurracy !== undefined && (obj.acurracy = message.acurracy);
return obj;
},
create(base) {
return Observation_4_Metadata_Position_Coords.fromPartial(base !== null && base !== void 0 ? base : {});
},
fromPartial(object) {
var _a, _b, _c, _d, _e, _f;
const message = createBaseObservation_4_Metadata_Position_Coords();
message.altitude = (_a = object.altitude) !== null && _a !== void 0 ? _a : 0;
message.heading = (_b = object.heading) !== null && _b !== void 0 ? _b : 0;
message.longitude = (_c = object.longitude) !== null && _c !== void 0 ? _c : 0;
message.latitude = (_d = object.latitude) !== null && _d !== void 0 ? _d : 0;
message.speed = (_e = object.speed) !== null && _e !== void 0 ? _e : 0;
message.acurracy = (_f = object.acurracy) !== null && _f !== void 0 ? _f : 0;
return message;
},
};
function createBaseObservation_4_Metadata_PositionProvider() {
return { gpsAvailable: false, passiveAvailable: false, locationServicesEnabled: false, networkAvailable: false };
}
export const Observation_4_Metadata_PositionProvider = {
encode(message, writer = _m0.Writer.create()) {
if (message.gpsAvailable === true) {
writer.uint32(8).bool(message.gpsAvailable);
}
if (message.passiveAvailable === true) {
writer.uint32(16).bool(message.passiveAvailable);
}
if (message.locationServicesEnabled === true) {
writer.uint32(24).bool(message.locationServicesEnabled);
}
if (message.networkAvailable === true) {
writer.uint32(32).bool(message.networkAvailable);
}
return writer;
},
decode(input, length) {
const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseObservation_4_Metadata_PositionProvider();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.gpsAvailable = reader.bool();
break;
case 2:
message.passiveAvailable = reader.bool();
break;
case 3:
message.locationServicesEnabled = reader.bool();
break;
case 4:
message.networkAvailable = reader.bool();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
gpsAvailable: isSet(object.gpsAvailable) ? Boolean(object.gpsAvailable) : false,
passiveAvailable: isSet(object.passiveAvailable) ? Boolean(object.passiveAvailable) : false,
locationServicesEnabled: isSet(object.locationServicesEnabled) ? Boolean(object.locationServicesEnabled) : false,
networkAvailable: isSet(object.networkAvailable) ? Boolean(object.networkAvailable) : false,
};
},
toJSON(message) {
const obj = {};
message.gpsAvailable !== undefined && (obj.gpsAvailable = message.gpsAvailable);
message.passiveAvailable !== undefined && (obj.passiveAvailable = message.passiveAvailable);
message.locationServicesEnabled !== undefined && (obj.locationServicesEnabled = message.locationServicesEnabled);
message.networkAvailable !== undefined && (obj.networkAvailable = message.networkAvailable);
return obj;
},
create(base) {
return Observation_4_Metadata_PositionProvider.fromPartial(base !== null && base !== void 0 ? base : {});
},
fromPartial(object) {
var _a, _b, _c, _d;
const message = createBaseObservation_4_Metadata_PositionProvider();
message.gpsAvailable = (_a = object.gpsAvailable) !== null && _a !== void 0 ? _a : false;
message.passiveAvailable = (_b = object.passiveAvailable) !== null && _b !== void 0 ? _b : false;
message.locationServicesEnabled = (_c = object.locationServicesEnabled) !== null && _c !== void 0 ? _c : false;
message.networkAvailable = (_d = object.networkAvailable) !== null && _d !== void 0 ? _d : false;
return message;
},
};
var tsProtoGlobalThis = (() => {
if (typeof globalThis !== "undefined") {
return globalThis;
}
if (typeof self !== "undefined") {
return self;
}
if (typeof window !== "undefined") {
return window;
}
if (typeof global !== "undefined") {
return global;
}
throw "Unable to locate global object";
})();
function bytesFromBase64(b64) {
if (tsProtoGlobalThis.Buffer) {
return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
}
else {
const bin = tsProtoGlobalThis.atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; ++i) {
arr[i] = bin.charCodeAt(i);
}
return arr;
}
}
function base64FromBytes(arr) {
if (tsProtoGlobalThis.Buffer) {
return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
}
else {
const bin = [];
arr.forEach((byte) => {
bin.push(String.fromCharCode(byte));
});
return tsProtoGlobalThis.btoa(bin.join(""));
}
}
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.fromJSON(o));
}
}
function isObject(value) {
return typeof value === "object" && value !== null;
}
function isSet(value) {
return value !== null && value !== undefined;
}