livelists-node-js/dist/proto/channel.js

node.js server sdk for livelists

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CustomData_DataEntry = exports.CustomData = exports.CreateChannelReq = exports.CreateChannelResponse = exports.Channel = exports.createChannelErrorsToJSON = exports.createChannelErrorsFromJSON = exports.CreateChannelErrors = exports.channelStatusToJSON = exports.channelStatusFromJSON = exports.ChannelStatus = exports.protobufPackage = void 0;
/* eslint-disable */
const long_1 = __importDefault(require("long"));
const minimal_1 = __importDefault(require("protobufjs/minimal"));
const timestamp_1 = require("./google/protobuf/timestamp");
exports.protobufPackage = "channel";
var ChannelStatus;
(function (ChannelStatus) {
    ChannelStatus[ChannelStatus["Active"] = 0] = "Active";
    ChannelStatus[ChannelStatus["Archived"] = 1] = "Archived";
    ChannelStatus[ChannelStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(ChannelStatus || (exports.ChannelStatus = ChannelStatus = {}));
function channelStatusFromJSON(object) {
    switch (object) {
        case 0:
        case "Active":
            return ChannelStatus.Active;
        case 1:
        case "Archived":
            return ChannelStatus.Archived;
        case -1:
        case "UNRECOGNIZED":
        default:
            return ChannelStatus.UNRECOGNIZED;
    }
}
exports.channelStatusFromJSON = channelStatusFromJSON;
function channelStatusToJSON(object) {
    switch (object) {
        case ChannelStatus.Active:
            return "Active";
        case ChannelStatus.Archived:
            return "Archived";
        case ChannelStatus.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.channelStatusToJSON = channelStatusToJSON;
var CreateChannelErrors;
(function (CreateChannelErrors) {
    CreateChannelErrors[CreateChannelErrors["Unauthorized"] = 0] = "Unauthorized";
    CreateChannelErrors[CreateChannelErrors["IsAlreadyExist"] = 1] = "IsAlreadyExist";
    CreateChannelErrors[CreateChannelErrors["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(CreateChannelErrors || (exports.CreateChannelErrors = CreateChannelErrors = {}));
function createChannelErrorsFromJSON(object) {
    switch (object) {
        case 0:
        case "Unauthorized":
            return CreateChannelErrors.Unauthorized;
        case 1:
        case "IsAlreadyExist":
            return CreateChannelErrors.IsAlreadyExist;
        case -1:
        case "UNRECOGNIZED":
        default:
            return CreateChannelErrors.UNRECOGNIZED;
    }
}
exports.createChannelErrorsFromJSON = createChannelErrorsFromJSON;
function createChannelErrorsToJSON(object) {
    switch (object) {
        case CreateChannelErrors.Unauthorized:
            return "Unauthorized";
        case CreateChannelErrors.IsAlreadyExist:
            return "IsAlreadyExist";
        case CreateChannelErrors.UNRECOGNIZED:
        default:
            return "UNRECOGNIZED";
    }
}
exports.createChannelErrorsToJSON = createChannelErrorsToJSON;
function createBaseChannel() {
    return { identifier: "", createdAt: undefined, maxParticipants: 0, status: 0, customData: undefined };
}
exports.Channel = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.identifier !== "") {
            writer.uint32(10).string(message.identifier);
        }
        if (message.createdAt !== undefined) {
            timestamp_1.Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(18).fork()).ldelim();
        }
        if (message.maxParticipants !== 0) {
            writer.uint32(24).int64(message.maxParticipants);
        }
        if (message.status !== 0) {
            writer.uint32(32).int32(message.status);
        }
        if (message.customData !== undefined) {
            exports.CustomData.encode(message.customData, writer.uint32(42).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseChannel();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.identifier = reader.string();
                    break;
                case 2:
                    message.createdAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
                    break;
                case 3:
                    message.maxParticipants = longToNumber(reader.int64());
                    break;
                case 4:
                    message.status = reader.int32();
                    break;
                case 5:
                    message.customData = exports.CustomData.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            identifier: isSet(object.identifier) ? String(object.identifier) : "",
            createdAt: isSet(object.createdAt) ? fromJsonTimestamp(object.createdAt) : undefined,
            maxParticipants: isSet(object.maxParticipants) ? Number(object.maxParticipants) : 0,
            status: isSet(object.status) ? channelStatusFromJSON(object.status) : 0,
            customData: isSet(object.customData) ? exports.CustomData.fromJSON(object.customData) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.identifier !== undefined && (obj.identifier = message.identifier);
        message.createdAt !== undefined && (obj.createdAt = message.createdAt.toISOString());
        message.maxParticipants !== undefined && (obj.maxParticipants = Math.round(message.maxParticipants));
        message.status !== undefined && (obj.status = channelStatusToJSON(message.status));
        message.customData !== undefined &&
            (obj.customData = message.customData ? exports.CustomData.toJSON(message.customData) : undefined);
        return obj;
    },
    fromPartial(object) {
        var _a, _b, _c, _d;
        const message = createBaseChannel();
        message.identifier = (_a = object.identifier) !== null && _a !== void 0 ? _a : "";
        message.createdAt = (_b = object.createdAt) !== null && _b !== void 0 ? _b : undefined;
        message.maxParticipants = (_c = object.maxParticipants) !== null && _c !== void 0 ? _c : 0;
        message.status = (_d = object.status) !== null && _d !== void 0 ? _d : 0;
        message.customData = (object.customData !== undefined && object.customData !== null)
            ? exports.CustomData.fromPartial(object.customData)
            : undefined;
        return message;
    },
};
function createBaseCreateChannelResponse() {
    return { errors: [], channel: undefined };
}
exports.CreateChannelResponse = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        writer.uint32(10).fork();
        for (const v of message.errors) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.channel !== undefined) {
            exports.Channel.encode(message.channel, writer.uint32(18).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCreateChannelResponse();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if ((tag & 7) === 2) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.errors.push(reader.int32());
                        }
                    }
                    else {
                        message.errors.push(reader.int32());
                    }
                    break;
                case 2:
                    message.channel = exports.Channel.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            errors: Array.isArray(object === null || object === void 0 ? void 0 : object.errors) ? object.errors.map((e) => createChannelErrorsFromJSON(e)) : [],
            channel: isSet(object.channel) ? exports.Channel.fromJSON(object.channel) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.errors) {
            obj.errors = message.errors.map((e) => createChannelErrorsToJSON(e));
        }
        else {
            obj.errors = [];
        }
        message.channel !== undefined && (obj.channel = message.channel ? exports.Channel.toJSON(message.channel) : undefined);
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCreateChannelResponse();
        message.errors = ((_a = object.errors) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
        message.channel = (object.channel !== undefined && object.channel !== null)
            ? exports.Channel.fromPartial(object.channel)
            : undefined;
        return message;
    },
};
function createBaseCreateChannelReq() {
    return { identifier: "", maxParticipants: 0, customData: undefined };
}
exports.CreateChannelReq = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.identifier !== "") {
            writer.uint32(10).string(message.identifier);
        }
        if (message.maxParticipants !== 0) {
            writer.uint32(16).int64(message.maxParticipants);
        }
        if (message.customData !== undefined) {
            exports.CustomData.encode(message.customData, writer.uint32(26).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCreateChannelReq();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    message.identifier = reader.string();
                    break;
                case 2:
                    message.maxParticipants = longToNumber(reader.int64());
                    break;
                case 3:
                    message.customData = exports.CustomData.decode(reader, reader.uint32());
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            identifier: isSet(object.identifier) ? String(object.identifier) : "",
            maxParticipants: isSet(object.maxParticipants) ? Number(object.maxParticipants) : 0,
            customData: isSet(object.customData) ? exports.CustomData.fromJSON(object.customData) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        message.identifier !== undefined && (obj.identifier = message.identifier);
        message.maxParticipants !== undefined && (obj.maxParticipants = Math.round(message.maxParticipants));
        message.customData !== undefined &&
            (obj.customData = message.customData ? exports.CustomData.toJSON(message.customData) : undefined);
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCreateChannelReq();
        message.identifier = (_a = object.identifier) !== null && _a !== void 0 ? _a : "";
        message.maxParticipants = (_b = object.maxParticipants) !== null && _b !== void 0 ? _b : 0;
        message.customData = (object.customData !== undefined && object.customData !== null)
            ? exports.CustomData.fromPartial(object.customData)
            : undefined;
        return message;
    },
};
function createBaseCustomData() {
    return { data: {} };
}
exports.CustomData = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        Object.entries(message.data).forEach(([key, value]) => {
            exports.CustomData_DataEntry.encode({ key: key, value }, writer.uint32(10).fork()).ldelim();
        });
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCustomData();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    const entry1 = exports.CustomData_DataEntry.decode(reader, reader.uint32());
                    if (entry1.value !== undefined) {
                        message.data[entry1.key] = entry1.value;
                    }
                    break;
                default:
                    reader.skipType(tag & 7);
                    break;
            }
        }
        return message;
    },
    fromJSON(object) {
        return {
            data: isObject(object.data)
                ? Object.entries(object.data).reduce((acc, [key, value]) => {
                    acc[key] = String(value);
                    return acc;
                }, {})
                : {},
        };
    },
    toJSON(message) {
        const obj = {};
        obj.data = {};
        if (message.data) {
            Object.entries(message.data).forEach(([k, v]) => {
                obj.data[k] = v;
            });
        }
        return obj;
    },
    fromPartial(object) {
        var _a;
        const message = createBaseCustomData();
        message.data = Object.entries((_a = object.data) !== null && _a !== void 0 ? _a : {}).reduce((acc, [key, value]) => {
            if (value !== undefined) {
                acc[key] = String(value);
            }
            return acc;
        }, {});
        return message;
    },
};
function createBaseCustomData_DataEntry() {
    return { key: "", value: "" };
}
exports.CustomData_DataEntry = {
    encode(message, writer = minimal_1.default.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 minimal_1.default.Reader ? input : new minimal_1.default.Reader(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseCustomData_DataEntry();
        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;
    },
    fromJSON(object) {
        return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object.value) ? String(object.value) : "" };
    },
    toJSON(message) {
        const obj = {};
        message.key !== undefined && (obj.key = message.key);
        message.value !== undefined && (obj.value = message.value);
        return obj;
    },
    fromPartial(object) {
        var _a, _b;
        const message = createBaseCustomData_DataEntry();
        message.key = (_a = object.key) !== null && _a !== void 0 ? _a : "";
        message.value = (_b = object.value) !== null && _b !== void 0 ? _b : "";
        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 toTimestamp(date) {
    const seconds = date.getTime() / 1000;
    const nanos = (date.getTime() % 1000) * 1000000;
    return { seconds, nanos };
}
function fromTimestamp(t) {
    let millis = t.seconds * 1000;
    millis += t.nanos / 1000000;
    return new Date(millis);
}
function fromJsonTimestamp(o) {
    if (o instanceof Date) {
        return o;
    }
    else if (typeof o === "string") {
        return new Date(o);
    }
    else {
        return fromTimestamp(timestamp_1.Timestamp.fromJSON(o));
    }
}
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 (minimal_1.default.util.Long !== long_1.default) {
    minimal_1.default.util.Long = long_1.default;
    minimal_1.default.configure();
}
function isObject(value) {
    return typeof value === "object" && value !== null;
}
function isSet(value) {
    return value !== null && value !== undefined;
}
//# sourceMappingURL=channel.js.map