@xmtp/proto/ts/dist/esm/device_sync/content.pb.js

Protobuf client and generated classes for GRPC API

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v1.181.2
//   protoc               v3.21.12
// source: device_sync/content.proto
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { ConsentSave } from "./consent_backup.pb";
import { backupElementSelectionFromJSON, backupElementSelectionToJSON, BackupMetadataSave, BackupOptions, } from "./device_sync.pb";
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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.request = DeviceSyncRequest.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.acknowledge = DeviceSyncAcknowledge.decode(reader, reader.uint32());
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.reply = DeviceSyncReply.decode(reader, reader.uint32());
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.preferenceUpdates = PreferenceUpdates.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        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 = {};
        if (message.request !== undefined) {
            obj.request = DeviceSyncRequest.toJSON(message.request);
        }
        if (message.acknowledge !== undefined) {
            obj.acknowledge = DeviceSyncAcknowledge.toJSON(message.acknowledge);
        }
        if (message.reply !== undefined) {
            obj.reply = DeviceSyncReply.toJSON(message.reply);
        }
        if (message.preferenceUpdates !== undefined) {
            obj.preferenceUpdates = PreferenceUpdates.toJSON(message.preferenceUpdates);
        }
        return obj;
    },
    create(base) {
        return DeviceSyncContent.fromPartial(base ?? {});
    },
    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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.requestId = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : "" };
    },
    toJSON(message) {
        const obj = {};
        if (message.requestId !== "") {
            obj.requestId = message.requestId;
        }
        return obj;
    },
    create(base) {
        return DeviceSyncAcknowledge.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseDeviceSyncAcknowledge();
        message.requestId = object.requestId ?? "";
        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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.updates.push(PreferenceUpdate.decode(reader, reader.uint32()));
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            updates: globalThis.Array.isArray(object?.updates)
                ? object.updates.map((e) => PreferenceUpdate.fromJSON(e))
                : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.updates?.length) {
            obj.updates = message.updates.map((e) => PreferenceUpdate.toJSON(e));
        }
        return obj;
    },
    create(base) {
        return PreferenceUpdates.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBasePreferenceUpdates();
        message.updates = object.updates?.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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.consent = ConsentSave.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.hmac = HmacKeyUpdate.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        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 = {};
        if (message.consent !== undefined) {
            obj.consent = ConsentSave.toJSON(message.consent);
        }
        if (message.hmac !== undefined) {
            obj.hmac = HmacKeyUpdate.toJSON(message.hmac);
        }
        return obj;
    },
    create(base) {
        return PreferenceUpdate.fromPartial(base ?? {});
    },
    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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.contents.push(reader.bytes());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            contents: globalThis.Array.isArray(object?.contents) ? object.contents.map((e) => bytesFromBase64(e)) : [],
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.contents?.length) {
            obj.contents = message.contents.map((e) => base64FromBytes(e));
        }
        return obj;
    },
    create(base) {
        return V1UserPreferenceUpdate.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseV1UserPreferenceUpdate();
        message.contents = object.contents?.map((e) => e) || [];
        return message;
    },
};
function createBaseHmacKeyUpdate() {
    return { key: new Uint8Array(0), 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.equals(Long.ZERO)) {
            writer.uint32(16).int64(message.cycledAtNs);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.key = reader.bytes();
                    continue;
                case 2:
                    if (tag !== 16) {
                        break;
                    }
                    message.cycledAtNs = reader.int64();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            key: isSet(object.key) ? bytesFromBase64(object.key) : new Uint8Array(0),
            cycledAtNs: isSet(object.cycledAtNs) ? Long.fromValue(object.cycledAtNs) : Long.ZERO,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.key.length !== 0) {
            obj.key = base64FromBytes(message.key);
        }
        if (!message.cycledAtNs.equals(Long.ZERO)) {
            obj.cycledAtNs = (message.cycledAtNs || Long.ZERO).toString();
        }
        return obj;
    },
    create(base) {
        return HmacKeyUpdate.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseHmacKeyUpdate();
        message.key = object.key ?? new Uint8Array(0);
        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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.requestId = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.pinCode = reader.string();
                    continue;
                case 3:
                    if (tag !== 24) {
                        break;
                    }
                    message.kind = reader.int32();
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.options = BackupOptions.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : "",
            pinCode: isSet(object.pinCode) ? globalThis.String(object.pinCode) : "",
            kind: isSet(object.kind) ? backupElementSelectionFromJSON(object.kind) : 0,
            options: isSet(object.options) ? BackupOptions.fromJSON(object.options) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.requestId !== "") {
            obj.requestId = message.requestId;
        }
        if (message.pinCode !== "") {
            obj.pinCode = message.pinCode;
        }
        if (message.kind !== 0) {
            obj.kind = backupElementSelectionToJSON(message.kind);
        }
        if (message.options !== undefined) {
            obj.options = BackupOptions.toJSON(message.options);
        }
        return obj;
    },
    create(base) {
        return DeviceSyncRequest.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseDeviceSyncRequest();
        message.requestId = object.requestId ?? "";
        message.pinCode = object.pinCode ?? "";
        message.kind = object.kind ?? 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.equals(Long.UZERO)) {
            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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.requestId = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.url = reader.string();
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.encryptionKey = DeviceSyncKeyType.decode(reader, reader.uint32());
                    continue;
                case 4:
                    if (tag !== 32) {
                        break;
                    }
                    message.timestampNs = reader.uint64();
                    continue;
                case 5:
                    if (tag !== 40) {
                        break;
                    }
                    message.kind = reader.int32();
                    continue;
                case 6:
                    if (tag !== 50) {
                        break;
                    }
                    message.metadata = BackupMetadataSave.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            requestId: isSet(object.requestId) ? globalThis.String(object.requestId) : "",
            url: isSet(object.url) ? globalThis.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 = {};
        if (message.requestId !== "") {
            obj.requestId = message.requestId;
        }
        if (message.url !== "") {
            obj.url = message.url;
        }
        if (message.encryptionKey !== undefined) {
            obj.encryptionKey = DeviceSyncKeyType.toJSON(message.encryptionKey);
        }
        if (!message.timestampNs.equals(Long.UZERO)) {
            obj.timestampNs = (message.timestampNs || Long.UZERO).toString();
        }
        if (message.kind !== 0) {
            obj.kind = backupElementSelectionToJSON(message.kind);
        }
        if (message.metadata !== undefined) {
            obj.metadata = BackupMetadataSave.toJSON(message.metadata);
        }
        return obj;
    },
    create(base) {
        return DeviceSyncReply.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseDeviceSyncReply();
        message.requestId = object.requestId ?? "";
        message.url = object.url ?? "";
        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 = object.kind ?? 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 : _m0.Reader.create(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:
                    if (tag !== 10) {
                        break;
                    }
                    message.aes256Gcm = reader.bytes();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return { aes256Gcm: isSet(object.aes256Gcm) ? bytesFromBase64(object.aes256Gcm) : undefined };
    },
    toJSON(message) {
        const obj = {};
        if (message.aes256Gcm !== undefined) {
            obj.aes256Gcm = base64FromBytes(message.aes256Gcm);
        }
        return obj;
    },
    create(base) {
        return DeviceSyncKeyType.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseDeviceSyncKeyType();
        message.aes256Gcm = object.aes256Gcm ?? undefined;
        return message;
    },
};
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(globalThis.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;
}