@xmtp/proto
Version:
Protobuf client and generated classes for GRPC API
686 lines • 24.9 kB
JavaScript
/* eslint-disable */
import { BackupOptions, BackupMetadataSave, backupElementSelectionFromJSON, backupElementSelectionToJSON, } from "./device_sync.pb";
import Long from "long";
import { ConsentSave } from "./consent_backup.pb";
import _m0 from "protobufjs/minimal";
export const protobufPackage = "xmtp.device_sync.content";
function createBaseDeviceSyncContent() {
return {
request: undefined,
acknowledge: undefined,
reply: undefined,
preferenceUpdates: undefined,
};
}
export const DeviceSyncContent = {
encode(message, writer = _m0.Writer.create()) {
if (message.request !== undefined) {
DeviceSyncRequest.encode(message.request, writer.uint32(10).fork()).ldelim();
}
if (message.acknowledge !== undefined) {
DeviceSyncAcknowledge.encode(message.acknowledge, writer.uint32(18).fork()).ldelim();
}
if (message.reply !== undefined) {
DeviceSyncReply.encode(message.reply, writer.uint32(26).fork()).ldelim();
}
if (message.preferenceUpdates !== undefined) {
PreferenceUpdates.encode(message.preferenceUpdates, writer.uint32(34).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 = createBaseDeviceSyncContent();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.request = DeviceSyncRequest.decode(reader, reader.uint32());
break;
case 2:
message.acknowledge = DeviceSyncAcknowledge.decode(reader, reader.uint32());
break;
case 3:
message.reply = DeviceSyncReply.decode(reader, reader.uint32());
break;
case 4:
message.preferenceUpdates = PreferenceUpdates.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
request: isSet(object.request)
? DeviceSyncRequest.fromJSON(object.request)
: undefined,
acknowledge: isSet(object.acknowledge)
? DeviceSyncAcknowledge.fromJSON(object.acknowledge)
: undefined,
reply: isSet(object.reply)
? DeviceSyncReply.fromJSON(object.reply)
: undefined,
preferenceUpdates: isSet(object.preferenceUpdates)
? PreferenceUpdates.fromJSON(object.preferenceUpdates)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.request !== undefined &&
(obj.request = message.request
? DeviceSyncRequest.toJSON(message.request)
: undefined);
message.acknowledge !== undefined &&
(obj.acknowledge = message.acknowledge
? DeviceSyncAcknowledge.toJSON(message.acknowledge)
: undefined);
message.reply !== undefined &&
(obj.reply = message.reply
? DeviceSyncReply.toJSON(message.reply)
: undefined);
message.preferenceUpdates !== undefined &&
(obj.preferenceUpdates = message.preferenceUpdates
? PreferenceUpdates.toJSON(message.preferenceUpdates)
: undefined);
return obj;
},
fromPartial(object) {
const message = createBaseDeviceSyncContent();
message.request =
object.request !== undefined && object.request !== null
? DeviceSyncRequest.fromPartial(object.request)
: undefined;
message.acknowledge =
object.acknowledge !== undefined && object.acknowledge !== null
? DeviceSyncAcknowledge.fromPartial(object.acknowledge)
: undefined;
message.reply =
object.reply !== undefined && object.reply !== null
? DeviceSyncReply.fromPartial(object.reply)
: undefined;
message.preferenceUpdates =
object.preferenceUpdates !== undefined &&
object.preferenceUpdates !== null
? PreferenceUpdates.fromPartial(object.preferenceUpdates)
: undefined;
return message;
},
};
function createBaseDeviceSyncAcknowledge() {
return { requestId: "" };
}
export const DeviceSyncAcknowledge = {
encode(message, writer = _m0.Writer.create()) {
if (message.requestId !== "") {
writer.uint32(10).string(message.requestId);
}
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 = createBaseDeviceSyncAcknowledge();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.requestId = reader.string();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
requestId: isSet(object.requestId) ? String(object.requestId) : "",
};
},
toJSON(message) {
const obj = {};
message.requestId !== undefined && (obj.requestId = message.requestId);
return obj;
},
fromPartial(object) {
var _a;
const message = createBaseDeviceSyncAcknowledge();
message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : "";
return message;
},
};
function createBasePreferenceUpdates() {
return { updates: [] };
}
export const PreferenceUpdates = {
encode(message, writer = _m0.Writer.create()) {
for (const v of message.updates) {
PreferenceUpdate.encode(v, writer.uint32(10).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 = createBasePreferenceUpdates();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.updates.push(PreferenceUpdate.decode(reader, reader.uint32()));
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
updates: Array.isArray(object === null || object === void 0 ? void 0 : object.updates)
? object.updates.map((e) => PreferenceUpdate.fromJSON(e))
: [],
};
},
toJSON(message) {
const obj = {};
if (message.updates) {
obj.updates = message.updates.map((e) => e ? PreferenceUpdate.toJSON(e) : undefined);
}
else {
obj.updates = [];
}
return obj;
},
fromPartial(object) {
var _a;
const message = createBasePreferenceUpdates();
message.updates =
((_a = object.updates) === null || _a === void 0 ? void 0 : _a.map((e) => PreferenceUpdate.fromPartial(e))) || [];
return message;
},
};
function createBasePreferenceUpdate() {
return { consent: undefined, hmac: undefined };
}
export const PreferenceUpdate = {
encode(message, writer = _m0.Writer.create()) {
if (message.consent !== undefined) {
ConsentSave.encode(message.consent, writer.uint32(10).fork()).ldelim();
}
if (message.hmac !== undefined) {
HmacKeyUpdate.encode(message.hmac, writer.uint32(18).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 = createBasePreferenceUpdate();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.consent = ConsentSave.decode(reader, reader.uint32());
break;
case 2:
message.hmac = HmacKeyUpdate.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
consent: isSet(object.consent)
? ConsentSave.fromJSON(object.consent)
: undefined,
hmac: isSet(object.hmac)
? HmacKeyUpdate.fromJSON(object.hmac)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.consent !== undefined &&
(obj.consent = message.consent
? ConsentSave.toJSON(message.consent)
: undefined);
message.hmac !== undefined &&
(obj.hmac = message.hmac
? HmacKeyUpdate.toJSON(message.hmac)
: undefined);
return obj;
},
fromPartial(object) {
const message = createBasePreferenceUpdate();
message.consent =
object.consent !== undefined && object.consent !== null
? ConsentSave.fromPartial(object.consent)
: undefined;
message.hmac =
object.hmac !== undefined && object.hmac !== null
? HmacKeyUpdate.fromPartial(object.hmac)
: undefined;
return message;
},
};
function createBaseV1UserPreferenceUpdate() {
return { contents: [] };
}
export const V1UserPreferenceUpdate = {
encode(message, writer = _m0.Writer.create()) {
for (const v of message.contents) {
writer.uint32(10).bytes(v);
}
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 = createBaseV1UserPreferenceUpdate();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.contents.push(reader.bytes());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
contents: Array.isArray(object === null || object === void 0 ? void 0 : object.contents)
? object.contents.map((e) => bytesFromBase64(e))
: [],
};
},
toJSON(message) {
const obj = {};
if (message.contents) {
obj.contents = message.contents.map((e) => base64FromBytes(e !== undefined ? e : new Uint8Array()));
}
else {
obj.contents = [];
}
return obj;
},
fromPartial(object) {
var _a;
const message = createBaseV1UserPreferenceUpdate();
message.contents = ((_a = object.contents) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
return message;
},
};
function createBaseHmacKeyUpdate() {
return { key: new Uint8Array(), cycledAtNs: Long.ZERO };
}
export const HmacKeyUpdate = {
encode(message, writer = _m0.Writer.create()) {
if (message.key.length !== 0) {
writer.uint32(10).bytes(message.key);
}
if (!message.cycledAtNs.isZero()) {
writer.uint32(16).int64(message.cycledAtNs);
}
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 = createBaseHmacKeyUpdate();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.key = reader.bytes();
break;
case 2:
message.cycledAtNs = reader.int64();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(),
cycledAtNs: isSet(object.cycledAtNs)
? Long.fromValue(object.cycledAtNs)
: Long.ZERO,
};
},
toJSON(message) {
const obj = {};
message.key !== undefined &&
(obj.key = base64FromBytes(message.key !== undefined ? message.key : new Uint8Array()));
message.cycledAtNs !== undefined &&
(obj.cycledAtNs = (message.cycledAtNs || Long.ZERO).toString());
return obj;
},
fromPartial(object) {
var _a;
const message = createBaseHmacKeyUpdate();
message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
message.cycledAtNs =
object.cycledAtNs !== undefined && object.cycledAtNs !== null
? Long.fromValue(object.cycledAtNs)
: Long.ZERO;
return message;
},
};
function createBaseDeviceSyncRequest() {
return { requestId: "", pinCode: "", kind: 0, options: undefined };
}
export const DeviceSyncRequest = {
encode(message, writer = _m0.Writer.create()) {
if (message.requestId !== "") {
writer.uint32(10).string(message.requestId);
}
if (message.pinCode !== "") {
writer.uint32(18).string(message.pinCode);
}
if (message.kind !== 0) {
writer.uint32(24).int32(message.kind);
}
if (message.options !== undefined) {
BackupOptions.encode(message.options, writer.uint32(34).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 = createBaseDeviceSyncRequest();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.requestId = reader.string();
break;
case 2:
message.pinCode = reader.string();
break;
case 3:
message.kind = reader.int32();
break;
case 4:
message.options = BackupOptions.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
requestId: isSet(object.requestId) ? String(object.requestId) : "",
pinCode: isSet(object.pinCode) ? String(object.pinCode) : "",
kind: isSet(object.kind)
? backupElementSelectionFromJSON(object.kind)
: 0,
options: isSet(object.options)
? BackupOptions.fromJSON(object.options)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.requestId !== undefined && (obj.requestId = message.requestId);
message.pinCode !== undefined && (obj.pinCode = message.pinCode);
message.kind !== undefined &&
(obj.kind = backupElementSelectionToJSON(message.kind));
message.options !== undefined &&
(obj.options = message.options
? BackupOptions.toJSON(message.options)
: undefined);
return obj;
},
fromPartial(object) {
var _a, _b, _c;
const message = createBaseDeviceSyncRequest();
message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : "";
message.pinCode = (_b = object.pinCode) !== null && _b !== void 0 ? _b : "";
message.kind = (_c = object.kind) !== null && _c !== void 0 ? _c : 0;
message.options =
object.options !== undefined && object.options !== null
? BackupOptions.fromPartial(object.options)
: undefined;
return message;
},
};
function createBaseDeviceSyncReply() {
return {
requestId: "",
url: "",
encryptionKey: undefined,
timestampNs: Long.UZERO,
kind: 0,
metadata: undefined,
};
}
export const DeviceSyncReply = {
encode(message, writer = _m0.Writer.create()) {
if (message.requestId !== "") {
writer.uint32(10).string(message.requestId);
}
if (message.url !== "") {
writer.uint32(18).string(message.url);
}
if (message.encryptionKey !== undefined) {
DeviceSyncKeyType.encode(message.encryptionKey, writer.uint32(26).fork()).ldelim();
}
if (!message.timestampNs.isZero()) {
writer.uint32(32).uint64(message.timestampNs);
}
if (message.kind !== 0) {
writer.uint32(40).int32(message.kind);
}
if (message.metadata !== undefined) {
BackupMetadataSave.encode(message.metadata, writer.uint32(50).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 = createBaseDeviceSyncReply();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.requestId = reader.string();
break;
case 2:
message.url = reader.string();
break;
case 3:
message.encryptionKey = DeviceSyncKeyType.decode(reader, reader.uint32());
break;
case 4:
message.timestampNs = reader.uint64();
break;
case 5:
message.kind = reader.int32();
break;
case 6:
message.metadata = BackupMetadataSave.decode(reader, reader.uint32());
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
requestId: isSet(object.requestId) ? String(object.requestId) : "",
url: isSet(object.url) ? String(object.url) : "",
encryptionKey: isSet(object.encryptionKey)
? DeviceSyncKeyType.fromJSON(object.encryptionKey)
: undefined,
timestampNs: isSet(object.timestampNs)
? Long.fromValue(object.timestampNs)
: Long.UZERO,
kind: isSet(object.kind)
? backupElementSelectionFromJSON(object.kind)
: 0,
metadata: isSet(object.metadata)
? BackupMetadataSave.fromJSON(object.metadata)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.requestId !== undefined && (obj.requestId = message.requestId);
message.url !== undefined && (obj.url = message.url);
message.encryptionKey !== undefined &&
(obj.encryptionKey = message.encryptionKey
? DeviceSyncKeyType.toJSON(message.encryptionKey)
: undefined);
message.timestampNs !== undefined &&
(obj.timestampNs = (message.timestampNs || Long.UZERO).toString());
message.kind !== undefined &&
(obj.kind = backupElementSelectionToJSON(message.kind));
message.metadata !== undefined &&
(obj.metadata = message.metadata
? BackupMetadataSave.toJSON(message.metadata)
: undefined);
return obj;
},
fromPartial(object) {
var _a, _b, _c;
const message = createBaseDeviceSyncReply();
message.requestId = (_a = object.requestId) !== null && _a !== void 0 ? _a : "";
message.url = (_b = object.url) !== null && _b !== void 0 ? _b : "";
message.encryptionKey =
object.encryptionKey !== undefined && object.encryptionKey !== null
? DeviceSyncKeyType.fromPartial(object.encryptionKey)
: undefined;
message.timestampNs =
object.timestampNs !== undefined && object.timestampNs !== null
? Long.fromValue(object.timestampNs)
: Long.UZERO;
message.kind = (_c = object.kind) !== null && _c !== void 0 ? _c : 0;
message.metadata =
object.metadata !== undefined && object.metadata !== null
? BackupMetadataSave.fromPartial(object.metadata)
: undefined;
return message;
},
};
function createBaseDeviceSyncKeyType() {
return { aes256Gcm: undefined };
}
export const DeviceSyncKeyType = {
encode(message, writer = _m0.Writer.create()) {
if (message.aes256Gcm !== undefined) {
writer.uint32(10).bytes(message.aes256Gcm);
}
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 = createBaseDeviceSyncKeyType();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
message.aes256Gcm = reader.bytes();
break;
default:
reader.skipType(tag & 7);
break;
}
}
return message;
},
fromJSON(object) {
return {
aes256Gcm: isSet(object.aes256Gcm)
? bytesFromBase64(object.aes256Gcm)
: undefined,
};
},
toJSON(message) {
const obj = {};
message.aes256Gcm !== undefined &&
(obj.aes256Gcm =
message.aes256Gcm !== undefined
? base64FromBytes(message.aes256Gcm)
: undefined);
return obj;
},
fromPartial(object) {
var _a;
const message = createBaseDeviceSyncKeyType();
message.aes256Gcm = (_a = object.aes256Gcm) !== null && _a !== void 0 ? _a : undefined;
return message;
},
};
var globalThis = (() => {
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 (globalThis.Buffer) {
return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
}
else {
const bin = globalThis.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 (globalThis.Buffer) {
return globalThis.Buffer.from(arr).toString("base64");
}
else {
const bin = [];
arr.forEach((byte) => {
bin.push(String.fromCharCode(byte));
});
return globalThis.btoa(bin.join(""));
}
}
if (_m0.util.Long !== Long) {
_m0.util.Long = Long;
_m0.configure();
}
function isSet(value) {
return value !== null && value !== undefined;
}
//# sourceMappingURL=content.pb.js.map