@snap/camera-kit 0.7.0

package/lib/generated-proto/pb_schema/lenses/snappable.js

@@ -0,0 +1,954 @@
+/* eslint-disable */
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+export const protobufPackage = "snapchat.lenses.snappable";
+export var EncryptionData_EncryptionScheme;
+(function (EncryptionData_EncryptionScheme) {
+    EncryptionData_EncryptionScheme["NOT_APPLICABLE"] = "NOT_APPLICABLE";
+    EncryptionData_EncryptionScheme["SPOOKEY"] = "SPOOKEY";
+    EncryptionData_EncryptionScheme["REGISTRY"] = "REGISTRY";
+    /** FIDELIUS - Add others as necessary */
+    EncryptionData_EncryptionScheme["FIDELIUS"] = "FIDELIUS";
+    EncryptionData_EncryptionScheme["UNRECOGNIZED"] = "UNRECOGNIZED";
+})(EncryptionData_EncryptionScheme || (EncryptionData_EncryptionScheme = {}));
+export function encryptionData_EncryptionSchemeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "NOT_APPLICABLE":
+            return EncryptionData_EncryptionScheme.NOT_APPLICABLE;
+        case 1:
+        case "SPOOKEY":
+            return EncryptionData_EncryptionScheme.SPOOKEY;
+        case 2:
+        case "REGISTRY":
+            return EncryptionData_EncryptionScheme.REGISTRY;
+        case 3:
+        case "FIDELIUS":
+            return EncryptionData_EncryptionScheme.FIDELIUS;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return EncryptionData_EncryptionScheme.UNRECOGNIZED;
+    }
+}
+export function encryptionData_EncryptionSchemeToNumber(object) {
+    switch (object) {
+        case EncryptionData_EncryptionScheme.NOT_APPLICABLE:
+            return 0;
+        case EncryptionData_EncryptionScheme.SPOOKEY:
+            return 1;
+        case EncryptionData_EncryptionScheme.REGISTRY:
+            return 2;
+        case EncryptionData_EncryptionScheme.FIDELIUS:
+            return 3;
+        default:
+            return 0;
+    }
+}
+export var SnappableMessage_ReplyType;
+(function (SnappableMessage_ReplyType) {
+    SnappableMessage_ReplyType["NOT_APPLICABLE"] = "NOT_APPLICABLE";
+    SnappableMessage_ReplyType["CONTEXT"] = "CONTEXT";
+    SnappableMessage_ReplyType["INTERSTITIAL"] = "INTERSTITIAL";
+    SnappableMessage_ReplyType["UNRECOGNIZED"] = "UNRECOGNIZED";
+})(SnappableMessage_ReplyType || (SnappableMessage_ReplyType = {}));
+export function snappableMessage_ReplyTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "NOT_APPLICABLE":
+            return SnappableMessage_ReplyType.NOT_APPLICABLE;
+        case 1:
+        case "CONTEXT":
+            return SnappableMessage_ReplyType.CONTEXT;
+        case 2:
+        case "INTERSTITIAL":
+            return SnappableMessage_ReplyType.INTERSTITIAL;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return SnappableMessage_ReplyType.UNRECOGNIZED;
+    }
+}
+export function snappableMessage_ReplyTypeToNumber(object) {
+    switch (object) {
+        case SnappableMessage_ReplyType.NOT_APPLICABLE:
+            return 0;
+        case SnappableMessage_ReplyType.CONTEXT:
+            return 1;
+        case SnappableMessage_ReplyType.INTERSTITIAL:
+            return 2;
+        default:
+            return 0;
+    }
+}
+function createBaseEncryptionData() {
+    return {
+        key: new Uint8Array(),
+        ivStore: {},
+        isKeyServerEncrypted: false,
+        isKeyE2eEncrypted: false,
+        encryptionScheme: EncryptionData_EncryptionScheme.NOT_APPLICABLE,
+    };
+}
+export const EncryptionData = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.key.length !== 0) {
+            writer.uint32(10).bytes(message.key);
+        }
+        Object.entries(message.ivStore).forEach(([key, value]) => {
+            EncryptionData_IvStoreEntry.encode({ key: key, value }, writer.uint32(18).fork()).ldelim();
+        });
+        if (message.isKeyServerEncrypted === true) {
+            writer.uint32(24).bool(message.isKeyServerEncrypted);
+        }
+        if (message.isKeyE2eEncrypted === true) {
+            writer.uint32(32).bool(message.isKeyE2eEncrypted);
+        }
+        if (message.encryptionScheme !== EncryptionData_EncryptionScheme.NOT_APPLICABLE) {
+            writer.uint32(40).int32(encryptionData_EncryptionSchemeToNumber(message.encryptionScheme));
+        }
+        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 = createBaseEncryptionData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.bytes();
+                    break;
+                case 2:
+                    const entry2 = EncryptionData_IvStoreEntry.decode(reader, reader.uint32());
+                    if (entry2.value !== undefined) {
+                        message.ivStore[entry2.key] = entry2.value;
+                    }
+                    break;
+                case 3:
+                    message.isKeyServerEncrypted = reader.bool();
+                    break;
+                case 4:
+                    message.isKeyE2eEncrypted = reader.bool();
+                    break;
+                case 5:
+                    message.encryptionScheme = encryptionData_EncryptionSchemeFromJSON(reader.int32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e;
+        const message = createBaseEncryptionData();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : new Uint8Array();
+        message.ivStore = Object.entries((_b = object.ivStore) !== null && _b !== void 0 ? _b : {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = value;
+            }
+            return acc;
+        }, {});
+        message.isKeyServerEncrypted = (_c = object.isKeyServerEncrypted) !== null && _c !== void 0 ? _c : false;
+        message.isKeyE2eEncrypted = (_d = object.isKeyE2eEncrypted) !== null && _d !== void 0 ? _d : false;
+        message.encryptionScheme = (_e = object.encryptionScheme) !== null && _e !== void 0 ? _e : EncryptionData_EncryptionScheme.NOT_APPLICABLE;
+        return message;
+    },
+};
+function createBaseEncryptionData_IvStoreEntry() {
+    return { key: "", value: new Uint8Array() };
+}
+export const EncryptionData_IvStoreEntry = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value.length !== 0) {
+            writer.uint32(18).bytes(message.value);
+        }
+        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 = createBaseEncryptionData_IvStoreEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseEncryptionData_IvStoreEntry();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
+        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : new Uint8Array();
+        return message;
+    },
+};
+function createBasePlayerData() {
+    return { store: {}, serializedStore: new Uint8Array() };
+}
+export const PlayerData = {
+    encode(message, writer = _m0.Writer.create()) {
+        Object.entries(message.store).forEach(([key, value]) => {
+            PlayerData_StoreEntry.encode({ key: key, value }, writer.uint32(10).fork()).ldelim();
+        });
+        if (message.serializedStore.length !== 0) {
+            writer.uint32(18).bytes(message.serializedStore);
+        }
+        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 = createBasePlayerData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    const entry1 = PlayerData_StoreEntry.decode(reader, reader.uint32());
+                    if (entry1.value !== undefined) {
+                        message.store[entry1.key] = entry1.value;
+                    }
+                    break;
+                case 2:
+                    message.serializedStore = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBasePlayerData();
+        message.store = Object.entries((_a = object.store) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {});
+        message.serializedStore = (_b = object.serializedStore) !== null && _b !== void 0 ? _b : new Uint8Array();
+        return message;
+    },
+};
+function createBasePlayerData_StoreEntry() {
+    return { key: "", value: "" };
+}
+export const PlayerData_StoreEntry = {
+    encode(message, writer = _m0.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 _m0.Reader ? input : new _m0.Reader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePlayerData_StoreEntry();
+        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;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBasePlayerData_StoreEntry();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
+        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : "";
+        return message;
+    },
+};
+function createBaseSessionData() {
+    return { playerData: {} };
+}
+export const SessionData = {
+    encode(message, writer = _m0.Writer.create()) {
+        Object.entries(message.playerData).forEach(([key, value]) => {
+            SessionData_PlayerDataEntry.encode({ key: key, value }, 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 = createBaseSessionData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    const entry1 = SessionData_PlayerDataEntry.decode(reader, reader.uint32());
+                    if (entry1.value !== undefined) {
+                        message.playerData[entry1.key] = entry1.value;
+                    }
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseSessionData();
+        message.playerData = Object.entries((_a = object.playerData) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = PlayerData.fromPartial(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseSessionData_PlayerDataEntry() {
+    return { key: "", value: undefined };
+}
+export const SessionData_PlayerDataEntry = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== undefined) {
+            PlayerData.encode(message.value, 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 = createBaseSessionData_PlayerDataEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.key = reader.string();
+                    break;
+                case 2:
+                    message.value = PlayerData.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseSessionData_PlayerDataEntry();
+        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
+        message.value =
+            object.value !== undefined && object.value !== null ? PlayerData.fromPartial(object.value) : undefined;
+        return message;
+    },
+};
+function createBaseSnappableMedia() {
+    return { sessionId: "", playerId: "", url: "", key: "", createdTime: 0 };
+}
+export const SnappableMedia = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.sessionId !== "") {
+            writer.uint32(10).string(message.sessionId);
+        }
+        if (message.playerId !== "") {
+            writer.uint32(18).string(message.playerId);
+        }
+        if (message.url !== "") {
+            writer.uint32(26).string(message.url);
+        }
+        if (message.key !== "") {
+            writer.uint32(34).string(message.key);
+        }
+        if (message.createdTime !== 0) {
+            writer.uint32(40).int64(message.createdTime);
+        }
+        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 = createBaseSnappableMedia();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.sessionId = reader.string();
+                    break;
+                case 2:
+                    message.playerId = reader.string();
+                    break;
+                case 3:
+                    message.url = reader.string();
+                    break;
+                case 4:
+                    message.key = reader.string();
+                    break;
+                case 5:
+                    message.createdTime = longToNumber(reader.int64());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e;
+        const message = createBaseSnappableMedia();
+        message.sessionId = (_a = object.sessionId) !== null && _a !== void 0 ? _a : "";
+        message.playerId = (_b = object.playerId) !== null && _b !== void 0 ? _b : "";
+        message.url = (_c = object.url) !== null && _c !== void 0 ? _c : "";
+        message.key = (_d = object.key) !== null && _d !== void 0 ? _d : "";
+        message.createdTime = (_e = object.createdTime) !== null && _e !== void 0 ? _e : 0;
+        return message;
+    },
+};
+function createBaseSnap3DData() {
+    return { allowZippedMedia: false };
+}
+export const Snap3DData = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.allowZippedMedia === true) {
+            writer.uint32(8).bool(message.allowZippedMedia);
+        }
+        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 = createBaseSnap3DData();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.allowZippedMedia = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseSnap3DData();
+        message.allowZippedMedia = (_a = object.allowZippedMedia) !== null && _a !== void 0 ? _a : false;
+        return message;
+    },
+};
+function createBaseUsesCameraRoll() {
+    return { usesCameraRoll: false };
+}
+export const UsesCameraRoll = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.usesCameraRoll === true) {
+            writer.uint32(8).bool(message.usesCameraRoll);
+        }
+        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 = createBaseUsesCameraRoll();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.usesCameraRoll = reader.bool();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseUsesCameraRoll();
+        message.usesCameraRoll = (_a = object.usesCameraRoll) !== null && _a !== void 0 ? _a : false;
+        return message;
+    },
+};
+function createBaseSnappableMessage() {
+    return {
+        snappable: undefined,
+        media: [],
+        effectId: "",
+        userIds: [],
+        focusPointX: 0,
+        focusPointY: 0,
+        focusPointWidth: 0,
+        replyType: SnappableMessage_ReplyType.NOT_APPLICABLE,
+        snap3dData: undefined,
+        usesCameraRollData: undefined,
+        assetBatchId: "",
+    };
+}
+export const SnappableMessage = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.snappable !== undefined) {
+            Snappable.encode(message.snappable, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.media) {
+            SnappableMedia.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        if (message.effectId !== "") {
+            writer.uint32(26).string(message.effectId);
+        }
+        for (const v of message.userIds) {
+            writer.uint32(34).string(v);
+        }
+        if (message.focusPointX !== 0) {
+            writer.uint32(45).float(message.focusPointX);
+        }
+        if (message.focusPointY !== 0) {
+            writer.uint32(53).float(message.focusPointY);
+        }
+        if (message.focusPointWidth !== 0) {
+            writer.uint32(61).float(message.focusPointWidth);
+        }
+        if (message.replyType !== SnappableMessage_ReplyType.NOT_APPLICABLE) {
+            writer.uint32(64).int32(snappableMessage_ReplyTypeToNumber(message.replyType));
+        }
+        if (message.snap3dData !== undefined) {
+            Snap3DData.encode(message.snap3dData, writer.uint32(74).fork()).ldelim();
+        }
+        if (message.usesCameraRollData !== undefined) {
+            UsesCameraRoll.encode(message.usesCameraRollData, writer.uint32(82).fork()).ldelim();
+        }
+        if (message.assetBatchId !== "") {
+            writer.uint32(4002).string(message.assetBatchId);
+        }
+        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 = createBaseSnappableMessage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.snappable = Snappable.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.media.push(SnappableMedia.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.effectId = reader.string();
+                    break;
+                case 4:
+                    message.userIds.push(reader.string());
+                    break;
+                case 5:
+                    message.focusPointX = reader.float();
+                    break;
+                case 6:
+                    message.focusPointY = reader.float();
+                    break;
+                case 7:
+                    message.focusPointWidth = reader.float();
+                    break;
+                case 8:
+                    message.replyType = snappableMessage_ReplyTypeFromJSON(reader.int32());
+                    break;
+                case 9:
+                    message.snap3dData = Snap3DData.decode(reader, reader.uint32());
+                    break;
+                case 10:
+                    message.usesCameraRollData = UsesCameraRoll.decode(reader, reader.uint32());
+                    break;
+                case 500:
+                    message.assetBatchId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const message = createBaseSnappableMessage();
+        message.snappable =
+            object.snappable !== undefined && object.snappable !== null ? Snappable.fromPartial(object.snappable) : undefined;
+        message.media = ((_a = object.media) === null || _a === void 0 ? void 0 : _a.map((e) => SnappableMedia.fromPartial(e))) || [];
+        message.effectId = (_b = object.effectId) !== null && _b !== void 0 ? _b : "";
+        message.userIds = ((_c = object.userIds) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
+        message.focusPointX = (_d = object.focusPointX) !== null && _d !== void 0 ? _d : 0;
+        message.focusPointY = (_e = object.focusPointY) !== null && _e !== void 0 ? _e : 0;
+        message.focusPointWidth = (_f = object.focusPointWidth) !== null && _f !== void 0 ? _f : 0;
+        message.replyType = (_g = object.replyType) !== null && _g !== void 0 ? _g : SnappableMessage_ReplyType.NOT_APPLICABLE;
+        message.snap3dData =
+            object.snap3dData !== undefined && object.snap3dData !== null
+                ? Snap3DData.fromPartial(object.snap3dData)
+                : undefined;
+        message.usesCameraRollData =
+            object.usesCameraRollData !== undefined && object.usesCameraRollData !== null
+                ? UsesCameraRoll.fromPartial(object.usesCameraRollData)
+                : undefined;
+        message.assetBatchId = (_h = object.assetBatchId) !== null && _h !== void 0 ? _h : "";
+        return message;
+    },
+};
+function createBaseSnappable() {
+    return {
+        id: "",
+        sessionId: "",
+        playerId: "",
+        sessionData: undefined,
+        createdTime: 0,
+        expireTime: 0,
+        version: 0,
+        encryptionData: undefined,
+        sessionDepth: 0,
+    };
+}
+export const Snappable = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message.sessionId !== "") {
+            writer.uint32(18).string(message.sessionId);
+        }
+        if (message.playerId !== "") {
+            writer.uint32(26).string(message.playerId);
+        }
+        if (message.sessionData !== undefined) {
+            SessionData.encode(message.sessionData, writer.uint32(34).fork()).ldelim();
+        }
+        if (message.createdTime !== 0) {
+            writer.uint32(40).int64(message.createdTime);
+        }
+        if (message.expireTime !== 0) {
+            writer.uint32(48).int64(message.expireTime);
+        }
+        if (message.version !== 0) {
+            writer.uint32(56).int32(message.version);
+        }
+        if (message.encryptionData !== undefined) {
+            EncryptionData.encode(message.encryptionData, writer.uint32(66).fork()).ldelim();
+        }
+        if (message.sessionDepth !== 0) {
+            writer.uint32(72).int32(message.sessionDepth);
+        }
+        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 = createBaseSnappable();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.string();
+                    break;
+                case 2:
+                    message.sessionId = reader.string();
+                    break;
+                case 3:
+                    message.playerId = reader.string();
+                    break;
+                case 4:
+                    message.sessionData = SessionData.decode(reader, reader.uint32());
+                    break;
+                case 5:
+                    message.createdTime = longToNumber(reader.int64());
+                    break;
+                case 6:
+                    message.expireTime = longToNumber(reader.int64());
+                    break;
+                case 7:
+                    message.version = reader.int32();
+                    break;
+                case 8:
+                    message.encryptionData = EncryptionData.decode(reader, reader.uint32());
+                    break;
+                case 9:
+                    message.sessionDepth = reader.int32();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const message = createBaseSnappable();
+        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : "";
+        message.sessionId = (_b = object.sessionId) !== null && _b !== void 0 ? _b : "";
+        message.playerId = (_c = object.playerId) !== null && _c !== void 0 ? _c : "";
+        message.sessionData =
+            object.sessionData !== undefined && object.sessionData !== null
+                ? SessionData.fromPartial(object.sessionData)
+                : undefined;
+        message.createdTime = (_d = object.createdTime) !== null && _d !== void 0 ? _d : 0;
+        message.expireTime = (_e = object.expireTime) !== null && _e !== void 0 ? _e : 0;
+        message.version = (_f = object.version) !== null && _f !== void 0 ? _f : 0;
+        message.encryptionData =
+            object.encryptionData !== undefined && object.encryptionData !== null
+                ? EncryptionData.fromPartial(object.encryptionData)
+                : undefined;
+        message.sessionDepth = (_g = object.sessionDepth) !== null && _g !== void 0 ? _g : 0;
+        return message;
+    },
+};
+function createBasePutSnappableRequest() {
+    return { snappable: undefined, media: [] };
+}
+export const PutSnappableRequest = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.snappable !== undefined) {
+            Snappable.encode(message.snappable, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.media) {
+            SnappableMedia.encode(v, 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 = createBasePutSnappableRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.snappable = Snappable.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.media.push(SnappableMedia.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBasePutSnappableRequest();
+        message.snappable =
+            object.snappable !== undefined && object.snappable !== null ? Snappable.fromPartial(object.snappable) : undefined;
+        message.media = ((_a = object.media) === null || _a === void 0 ? void 0 : _a.map((e) => SnappableMedia.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBasePutSnappableResponse() {
+    return { id: "" };
+}
+export const PutSnappableResponse = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        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 = createBasePutSnappableResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBasePutSnappableResponse();
+        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+function createBaseGetSnappableRequest() {
+    return { id: "" };
+}
+export const GetSnappableRequest = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        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 = createBaseGetSnappableRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseGetSnappableRequest();
+        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+function createBaseGetSnappableResponse() {
+    return { data: undefined, media: [] };
+}
+export const GetSnappableResponse = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.data !== undefined) {
+            Snappable.encode(message.data, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.media) {
+            SnappableMedia.encode(v, 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 = createBaseGetSnappableResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.data = Snappable.decode(reader, reader.uint32());
+                    break;
+                case 2:
+                    message.media.push(SnappableMedia.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseGetSnappableResponse();
+        message.data = object.data !== undefined && object.data !== null ? Snappable.fromPartial(object.data) : undefined;
+        message.media = ((_a = object.media) === null || _a === void 0 ? void 0 : _a.map((e) => SnappableMedia.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBaseSnappableEncryptedKey() {
+    return { encryptedKey: new Uint8Array(), encryptionKeyId: "", encryptionKeyIv: new Uint8Array() };
+}
+export const SnappableEncryptedKey = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.encryptedKey.length !== 0) {
+            writer.uint32(10).bytes(message.encryptedKey);
+        }
+        if (message.encryptionKeyId !== "") {
+            writer.uint32(18).string(message.encryptionKeyId);
+        }
+        if (message.encryptionKeyIv.length !== 0) {
+            writer.uint32(26).bytes(message.encryptionKeyIv);
+        }
+        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 = createBaseSnappableEncryptedKey();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.encryptedKey = reader.bytes();
+                    break;
+                case 2:
+                    message.encryptionKeyId = reader.string();
+                    break;
+                case 3:
+                    message.encryptionKeyIv = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        var _a, _b, _c;
+        const message = createBaseSnappableEncryptedKey();
+        message.encryptedKey = (_a = object.encryptedKey) !== null && _a !== void 0 ? _a : new Uint8Array();
+        message.encryptionKeyId = (_b = object.encryptionKeyId) !== null && _b !== void 0 ? _b : "";
+        message.encryptionKeyIv = (_c = object.encryptionKeyIv) !== null && _c !== void 0 ? _c : new Uint8Array();
+        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 longToNumber(long) {
+    if (long.gt(Number.MAX_SAFE_INTEGER)) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    return long.toNumber();
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}
+//# sourceMappingURL=snappable.js.map