@xmtp/proto/ts/dist/esm/message_contents/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: message_contents/content.proto
/* eslint-disable */
import Long from "long";
import _m0 from "protobufjs/minimal";
import { SignedPublicKeyBundle } from "./public_key.pb";
import { Signature } from "./signature.pb";
export const protobufPackage = "xmtp.message_contents";
/** Message content encoding structures */
/**
 * Recognized compression algorithms
 * protolint:disable ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
 */
export var Compression;
(function (Compression) {
    Compression[Compression["COMPRESSION_DEFLATE"] = 0] = "COMPRESSION_DEFLATE";
    Compression[Compression["COMPRESSION_GZIP"] = 1] = "COMPRESSION_GZIP";
    Compression[Compression["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(Compression || (Compression = {}));
export function compressionFromJSON(object) {
    switch (object) {
        case 0:
        case "COMPRESSION_DEFLATE":
            return Compression.COMPRESSION_DEFLATE;
        case 1:
        case "COMPRESSION_GZIP":
            return Compression.COMPRESSION_GZIP;
        case -1:
        case "UNRECOGNIZED":
        default:
            return Compression.UNRECOGNIZED;
    }
}
export function compressionToJSON(object) {
    switch (object) {
        case Compression.COMPRESSION_DEFLATE:
            return "COMPRESSION_DEFLATE";
        case Compression.COMPRESSION_GZIP:
            return "COMPRESSION_GZIP";
        case Compression.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
function createBaseContentTypeId() {
    return { authorityId: "", typeId: "", versionMajor: 0, versionMinor: 0 };
}
export const ContentTypeId = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.authorityId !== "") {
            writer.uint32(10).string(message.authorityId);
        }
        if (message.typeId !== "") {
            writer.uint32(18).string(message.typeId);
        }
        if (message.versionMajor !== 0) {
            writer.uint32(24).uint32(message.versionMajor);
        }
        if (message.versionMinor !== 0) {
            writer.uint32(32).uint32(message.versionMinor);
        }
        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 = createBaseContentTypeId();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.authorityId = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.typeId = reader.string();
                    continue;
                case 3:
                    if (tag !== 24) {
                        break;
                    }
                    message.versionMajor = reader.uint32();
                    continue;
                case 4:
                    if (tag !== 32) {
                        break;
                    }
                    message.versionMinor = reader.uint32();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            authorityId: isSet(object.authorityId) ? globalThis.String(object.authorityId) : "",
            typeId: isSet(object.typeId) ? globalThis.String(object.typeId) : "",
            versionMajor: isSet(object.versionMajor) ? globalThis.Number(object.versionMajor) : 0,
            versionMinor: isSet(object.versionMinor) ? globalThis.Number(object.versionMinor) : 0,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.authorityId !== "") {
            obj.authorityId = message.authorityId;
        }
        if (message.typeId !== "") {
            obj.typeId = message.typeId;
        }
        if (message.versionMajor !== 0) {
            obj.versionMajor = Math.round(message.versionMajor);
        }
        if (message.versionMinor !== 0) {
            obj.versionMinor = Math.round(message.versionMinor);
        }
        return obj;
    },
    create(base) {
        return ContentTypeId.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseContentTypeId();
        message.authorityId = object.authorityId ?? "";
        message.typeId = object.typeId ?? "";
        message.versionMajor = object.versionMajor ?? 0;
        message.versionMinor = object.versionMinor ?? 0;
        return message;
    },
};
function createBaseEncodedContent() {
    return { type: undefined, parameters: {}, fallback: undefined, compression: undefined, content: new Uint8Array(0) };
}
export const EncodedContent = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.type !== undefined) {
            ContentTypeId.encode(message.type, writer.uint32(10).fork()).ldelim();
        }
        Object.entries(message.parameters).forEach(([key, value]) => {
            EncodedContent_ParametersEntry.encode({ key: key, value }, writer.uint32(18).fork()).ldelim();
        });
        if (message.fallback !== undefined) {
            writer.uint32(26).string(message.fallback);
        }
        if (message.compression !== undefined) {
            writer.uint32(40).int32(message.compression);
        }
        if (message.content.length !== 0) {
            writer.uint32(34).bytes(message.content);
        }
        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 = createBaseEncodedContent();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.type = ContentTypeId.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    const entry2 = EncodedContent_ParametersEntry.decode(reader, reader.uint32());
                    if (entry2.value !== undefined) {
                        message.parameters[entry2.key] = entry2.value;
                    }
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.fallback = reader.string();
                    continue;
                case 5:
                    if (tag !== 40) {
                        break;
                    }
                    message.compression = reader.int32();
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.content = reader.bytes();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            type: isSet(object.type) ? ContentTypeId.fromJSON(object.type) : undefined,
            parameters: isObject(object.parameters)
                ? Object.entries(object.parameters).reduce((acc, [key, value]) => {
                    acc[key] = String(value);
                    return acc;
                }, {})
                : {},
            fallback: isSet(object.fallback) ? globalThis.String(object.fallback) : undefined,
            compression: isSet(object.compression) ? compressionFromJSON(object.compression) : undefined,
            content: isSet(object.content) ? bytesFromBase64(object.content) : new Uint8Array(0),
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.type !== undefined) {
            obj.type = ContentTypeId.toJSON(message.type);
        }
        if (message.parameters) {
            const entries = Object.entries(message.parameters);
            if (entries.length > 0) {
                obj.parameters = {};
                entries.forEach(([k, v]) => {
                    obj.parameters[k] = v;
                });
            }
        }
        if (message.fallback !== undefined) {
            obj.fallback = message.fallback;
        }
        if (message.compression !== undefined) {
            obj.compression = compressionToJSON(message.compression);
        }
        if (message.content.length !== 0) {
            obj.content = base64FromBytes(message.content);
        }
        return obj;
    },
    create(base) {
        return EncodedContent.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseEncodedContent();
        message.type = (object.type !== undefined && object.type !== null)
            ? ContentTypeId.fromPartial(object.type)
            : undefined;
        message.parameters = Object.entries(object.parameters ?? {}).reduce((acc, [key, value]) => {
            if (value !== undefined) {
                acc[key] = globalThis.String(value);
            }
            return acc;
        }, {});
        message.fallback = object.fallback ?? undefined;
        message.compression = object.compression ?? undefined;
        message.content = object.content ?? new Uint8Array(0);
        return message;
    },
};
function createBaseEncodedContent_ParametersEntry() {
    return { key: "", value: "" };
}
export const EncodedContent_ParametersEntry = {
    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 : _m0.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseEncodedContent_ParametersEntry();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.key = reader.string();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.value = reader.string();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            key: isSet(object.key) ? globalThis.String(object.key) : "",
            value: isSet(object.value) ? globalThis.String(object.value) : "",
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.key !== "") {
            obj.key = message.key;
        }
        if (message.value !== "") {
            obj.value = message.value;
        }
        return obj;
    },
    create(base) {
        return EncodedContent_ParametersEntry.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseEncodedContent_ParametersEntry();
        message.key = object.key ?? "";
        message.value = object.value ?? "";
        return message;
    },
};
function createBaseSignedContent() {
    return { payload: new Uint8Array(0), sender: undefined, signature: undefined };
}
export const SignedContent = {
    encode(message, writer = _m0.Writer.create()) {
        if (message.payload.length !== 0) {
            writer.uint32(10).bytes(message.payload);
        }
        if (message.sender !== undefined) {
            SignedPublicKeyBundle.encode(message.sender, writer.uint32(18).fork()).ldelim();
        }
        if (message.signature !== undefined) {
            Signature.encode(message.signature, writer.uint32(26).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 = createBaseSignedContent();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.payload = reader.bytes();
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.sender = SignedPublicKeyBundle.decode(reader, reader.uint32());
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.signature = Signature.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
            sender: isSet(object.sender) ? SignedPublicKeyBundle.fromJSON(object.sender) : undefined,
            signature: isSet(object.signature) ? Signature.fromJSON(object.signature) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.payload.length !== 0) {
            obj.payload = base64FromBytes(message.payload);
        }
        if (message.sender !== undefined) {
            obj.sender = SignedPublicKeyBundle.toJSON(message.sender);
        }
        if (message.signature !== undefined) {
            obj.signature = Signature.toJSON(message.signature);
        }
        return obj;
    },
    create(base) {
        return SignedContent.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseSignedContent();
        message.payload = object.payload ?? new Uint8Array(0);
        message.sender = (object.sender !== undefined && object.sender !== null)
            ? SignedPublicKeyBundle.fromPartial(object.sender)
            : undefined;
        message.signature = (object.signature !== undefined && object.signature !== null)
            ? Signature.fromPartial(object.signature)
            : 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 isObject(value) {
    return typeof value === "object" && value !== null;
}
function isSet(value) {
    return value !== null && value !== undefined;
}