@aseppxyzz12/baileys 1.1.8

package/WAProto/MdStorageMsgRowOpaqueData/MdStorageMsgRowOpaqueData.proto

@@ -0,0 +1,88 @@
+syntax = "proto3";
+package MdStorageMsgRowOpaqueData;
+
+import "../E2E/E2E.proto";
+
+message MsgOpaqueData {
+    optional string body = 1;
+    optional string caption = 3;
+    optional double lng = 5;
+    optional bool isLive = 6;
+    optional double lat = 7;
+    optional int32 paymentAmount1000 = 8;
+    optional string paymentNoteMsgBody = 9;
+    optional string matchedText = 11;
+    optional string title = 12;
+    optional string description = 13;
+    optional bytes futureproofBuffer = 14;
+    optional string clientUrl = 15;
+    optional string loc = 16;
+    optional string pollName = 17;
+    repeated PollOption pollOptions = 18;
+    optional uint32 pollSelectableOptionsCount = 20;
+    optional bytes messageSecret = 21;
+    optional string originalSelfAuthor = 51;
+    optional int64 senderTimestampMs = 22;
+    optional string pollUpdateParentKey = 23;
+    optional E2E.PollEncValue encPollVote = 24;
+    optional bool isSentCagPollCreation = 28;
+    optional PollContentType pollContentType = 42;
+    optional PollType pollType = 46;
+    optional int32 correctOptionIndex = 47;
+    optional PollVotesSnapshot pollVotesSnapshot = 41;
+    optional string encReactionTargetMessageKey = 25;
+    optional bytes encReactionEncPayload = 26;
+    optional bytes encReactionEncIv = 27;
+    optional bytes botMessageSecret = 29;
+    optional string targetMessageKey = 30;
+    optional bytes encPayload = 31;
+    optional bytes encIv = 32;
+    optional string eventName = 33;
+    optional bool isEventCanceled = 34;
+    optional string eventDescription = 35;
+    optional string eventJoinLink = 36;
+    optional int64 eventStartTime = 37;
+    optional EventLocation eventLocation = 38;
+    optional int64 eventEndTime = 40;
+    optional bool eventIsScheduledCall = 44;
+    optional bool eventExtraGuestsAllowed = 45;
+    optional bytes plainProtobufBytes = 43;
+    message EventLocation {
+        optional double degreesLatitude = 1;
+        optional double degreesLongitude = 2;
+        optional string name = 3;
+        optional string address = 4;
+        optional string url = 5;
+        optional bytes jpegThumbnail = 6;
+    }
+    enum PollContentType {
+        UNKNOWN = 0;
+        TEXT = 1;
+        IMAGE = 2;
+    }
+    message PollOption {
+        optional string name = 1;
+        optional string hash = 2;
+    }
+    enum PollType {
+        POLL = 0;
+        QUIZ = 1;
+    }
+    message PollVoteSnapshot {
+        optional MsgOpaqueData.PollOption option = 1;
+        optional int32 optionVoteCount = 2;
+    }
+    message PollVotesSnapshot {
+        repeated MsgOpaqueData.PollVoteSnapshot pollVotes = 1;
+    }
+}
+
+message PollEncValue {
+    optional bytes encPayload = 1;
+    optional bytes encIv = 2;
+}
+
+message MsgRowOpaqueData {
+    optional MsgOpaqueData currentMsg = 1;
+    optional MsgOpaqueData quotedMsg = 2;
+}

package/WAProto/MmsRetry/MmsRetry.js

@@ -0,0 +1,310 @@
+"use strict";
+var $protobuf = require("protobufjs/minimal");
+var $Reader = $protobuf.Reader,
+    $Writer = $protobuf.Writer,
+    $util = $protobuf.util;
+var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
+$root.MmsRetry = (function () {
+    var MmsRetry = {};
+    MmsRetry.ServerErrorReceipt = (function () {
+        function ServerErrorReceipt(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+        }
+        ServerErrorReceipt.prototype.stanzaId = null;
+        var $oneOfFields;
+        Object.defineProperty(ServerErrorReceipt.prototype, "_stanzaId", {
+            get: $util.oneOfGetter(($oneOfFields = ["stanzaId"])),
+            set: $util.oneOfSetter($oneOfFields),
+        });
+        ServerErrorReceipt.create = function create(properties) {
+            return new ServerErrorReceipt(properties);
+        };
+        ServerErrorReceipt.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.stanzaId != null && Object.hasOwnProperty.call(message, "stanzaId"))
+                writer.uint32(10).string(message.stanzaId);
+            return writer;
+        };
+        ServerErrorReceipt.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+        ServerErrorReceipt.decode = function decode(reader, length, error) {
+            if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length,
+                message = new $root.MmsRetry.ServerErrorReceipt();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                if (tag === error) break;
+                switch (tag >>> 3) {
+                    case 1: {
+                        message.stanzaId = reader.string();
+                        break;
+                    }
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        };
+        ServerErrorReceipt.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+        ServerErrorReceipt.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            var properties = {};
+            if (message.stanzaId != null && message.hasOwnProperty("stanzaId")) {
+                properties._stanzaId = 1;
+                if (!$util.isString(message.stanzaId)) return "stanzaId: string expected";
+            }
+            return null;
+        };
+        ServerErrorReceipt.fromObject = function fromObject(object) {
+            if (object instanceof $root.MmsRetry.ServerErrorReceipt) return object;
+            var message = new $root.MmsRetry.ServerErrorReceipt();
+            if (object.stanzaId != null) message.stanzaId = String(object.stanzaId);
+            return message;
+        };
+        ServerErrorReceipt.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (message.stanzaId != null && message.hasOwnProperty("stanzaId")) {
+                object.stanzaId = message.stanzaId;
+                if (options.oneofs) object._stanzaId = "stanzaId";
+            }
+            return object;
+        };
+        ServerErrorReceipt.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        ServerErrorReceipt.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/MmsRetry.ServerErrorReceipt";
+        };
+        return ServerErrorReceipt;
+    })();
+    MmsRetry.MediaRetryNotification = (function () {
+        function MediaRetryNotification(properties) {
+            if (properties)
+                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                    if (properties[keys[i]] != null) this[keys[i]] = properties[keys[i]];
+        }
+        MediaRetryNotification.prototype.stanzaId = null;
+        MediaRetryNotification.prototype.directPath = null;
+        MediaRetryNotification.prototype.result = null;
+        MediaRetryNotification.prototype.messageSecret = null;
+        var $oneOfFields;
+        Object.defineProperty(MediaRetryNotification.prototype, "_stanzaId", {
+            get: $util.oneOfGetter(($oneOfFields = ["stanzaId"])),
+            set: $util.oneOfSetter($oneOfFields),
+        });
+        Object.defineProperty(MediaRetryNotification.prototype, "_directPath", {
+            get: $util.oneOfGetter(($oneOfFields = ["directPath"])),
+            set: $util.oneOfSetter($oneOfFields),
+        });
+        Object.defineProperty(MediaRetryNotification.prototype, "_result", {
+            get: $util.oneOfGetter(($oneOfFields = ["result"])),
+            set: $util.oneOfSetter($oneOfFields),
+        });
+        Object.defineProperty(MediaRetryNotification.prototype, "_messageSecret", {
+            get: $util.oneOfGetter(($oneOfFields = ["messageSecret"])),
+            set: $util.oneOfSetter($oneOfFields),
+        });
+        MediaRetryNotification.create = function create(properties) {
+            return new MediaRetryNotification(properties);
+        };
+        MediaRetryNotification.encode = function encode(message, writer) {
+            if (!writer) writer = $Writer.create();
+            if (message.stanzaId != null && Object.hasOwnProperty.call(message, "stanzaId"))
+                writer.uint32(10).string(message.stanzaId);
+            if (message.directPath != null && Object.hasOwnProperty.call(message, "directPath"))
+                writer.uint32(18).string(message.directPath);
+            if (message.result != null && Object.hasOwnProperty.call(message, "result"))
+                writer.uint32(24).int32(message.result);
+            if (
+                message.messageSecret != null &&
+                Object.hasOwnProperty.call(message, "messageSecret")
+            )
+                writer.uint32(34).bytes(message.messageSecret);
+            return writer;
+        };
+        MediaRetryNotification.encodeDelimited = function encodeDelimited(message, writer) {
+            return this.encode(message, writer).ldelim();
+        };
+        MediaRetryNotification.decode = function decode(reader, length, error) {
+            if (!(reader instanceof $Reader)) reader = $Reader.create(reader);
+            var end = length === undefined ? reader.len : reader.pos + length,
+                message = new $root.MmsRetry.MediaRetryNotification();
+            while (reader.pos < end) {
+                var tag = reader.uint32();
+                if (tag === error) break;
+                switch (tag >>> 3) {
+                    case 1: {
+                        message.stanzaId = reader.string();
+                        break;
+                    }
+                    case 2: {
+                        message.directPath = reader.string();
+                        break;
+                    }
+                    case 3: {
+                        message.result = reader.int32();
+                        break;
+                    }
+                    case 4: {
+                        message.messageSecret = reader.bytes();
+                        break;
+                    }
+                    default:
+                        reader.skipType(tag & 7);
+                        break;
+                }
+            }
+            return message;
+        };
+        MediaRetryNotification.decodeDelimited = function decodeDelimited(reader) {
+            if (!(reader instanceof $Reader)) reader = new $Reader(reader);
+            return this.decode(reader, reader.uint32());
+        };
+        MediaRetryNotification.verify = function verify(message) {
+            if (typeof message !== "object" || message === null) return "object expected";
+            var properties = {};
+            if (message.stanzaId != null && message.hasOwnProperty("stanzaId")) {
+                properties._stanzaId = 1;
+                if (!$util.isString(message.stanzaId)) return "stanzaId: string expected";
+            }
+            if (message.directPath != null && message.hasOwnProperty("directPath")) {
+                properties._directPath = 1;
+                if (!$util.isString(message.directPath)) return "directPath: string expected";
+            }
+            if (message.result != null && message.hasOwnProperty("result")) {
+                properties._result = 1;
+                switch (message.result) {
+                    default:
+                        return "result: enum value expected";
+                    case 0:
+                    case 1:
+                    case 2:
+                    case 3:
+                        break;
+                }
+            }
+            if (message.messageSecret != null && message.hasOwnProperty("messageSecret")) {
+                properties._messageSecret = 1;
+                if (
+                    !(
+                        (message.messageSecret &&
+                            typeof message.messageSecret.length === "number") ||
+                        $util.isString(message.messageSecret)
+                    )
+                )
+                    return "messageSecret: buffer expected";
+            }
+            return null;
+        };
+        MediaRetryNotification.fromObject = function fromObject(object) {
+            if (object instanceof $root.MmsRetry.MediaRetryNotification) return object;
+            var message = new $root.MmsRetry.MediaRetryNotification();
+            if (object.stanzaId != null) message.stanzaId = String(object.stanzaId);
+            if (object.directPath != null) message.directPath = String(object.directPath);
+            switch (object.result) {
+                default:
+                    if (typeof object.result === "number") {
+                        message.result = object.result;
+                        break;
+                    }
+                    break;
+                case "GENERAL_ERROR":
+                case 0:
+                    message.result = 0;
+                    break;
+                case "SUCCESS":
+                case 1:
+                    message.result = 1;
+                    break;
+                case "NOT_FOUND":
+                case 2:
+                    message.result = 2;
+                    break;
+                case "DECRYPTION_ERROR":
+                case 3:
+                    message.result = 3;
+                    break;
+            }
+            if (object.messageSecret != null)
+                if (typeof object.messageSecret === "string")
+                    $util.base64.decode(
+                        object.messageSecret,
+                        (message.messageSecret = $util.newBuffer(
+                            $util.base64.length(object.messageSecret)
+                        )),
+                        0
+                    );
+                else if (object.messageSecret.length >= 0)
+                    message.messageSecret = object.messageSecret;
+            return message;
+        };
+        MediaRetryNotification.toObject = function toObject(message, options) {
+            if (!options) options = {};
+            var object = {};
+            if (message.stanzaId != null && message.hasOwnProperty("stanzaId")) {
+                object.stanzaId = message.stanzaId;
+                if (options.oneofs) object._stanzaId = "stanzaId";
+            }
+            if (message.directPath != null && message.hasOwnProperty("directPath")) {
+                object.directPath = message.directPath;
+                if (options.oneofs) object._directPath = "directPath";
+            }
+            if (message.result != null && message.hasOwnProperty("result")) {
+                object.result =
+                    options.enums === String
+                        ? $root.MmsRetry.MediaRetryNotification.ResultType[message.result] ===
+                          undefined
+                            ? message.result
+                            : $root.MmsRetry.MediaRetryNotification.ResultType[message.result]
+                        : message.result;
+                if (options.oneofs) object._result = "result";
+            }
+            if (message.messageSecret != null && message.hasOwnProperty("messageSecret")) {
+                object.messageSecret =
+                    options.bytes === String
+                        ? $util.base64.encode(
+                              message.messageSecret,
+                              0,
+                              message.messageSecret.length
+                          )
+                        : options.bytes === Array
+                          ? Array.prototype.slice.call(message.messageSecret)
+                          : message.messageSecret;
+                if (options.oneofs) object._messageSecret = "messageSecret";
+            }
+            return object;
+        };
+        MediaRetryNotification.prototype.toJSON = function toJSON() {
+            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+        };
+        MediaRetryNotification.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+            if (typeUrlPrefix === undefined) {
+                typeUrlPrefix = "type.googleapis.com";
+            }
+            return typeUrlPrefix + "/MmsRetry.MediaRetryNotification";
+        };
+        MediaRetryNotification.ResultType = (function () {
+            var valuesById = {},
+                values = Object.create(valuesById);
+            values[(valuesById[0] = "GENERAL_ERROR")] = 0;
+            values[(valuesById[1] = "SUCCESS")] = 1;
+            values[(valuesById[2] = "NOT_FOUND")] = 2;
+            values[(valuesById[3] = "DECRYPTION_ERROR")] = 3;
+            return values;
+        })();
+        return MediaRetryNotification;
+    })();
+    return MmsRetry;
+})();
+module.exports = $root;

package/WAProto/MmsRetry/MmsRetry.proto

@@ -0,0 +1,19 @@
+syntax = "proto3";
+package MmsRetry;
+
+message ServerErrorReceipt {
+    optional string stanzaId = 1;
+}
+
+message MediaRetryNotification {
+    optional string stanzaId = 1;
+    optional string directPath = 2;
+    optional ResultType result = 3;
+    optional bytes messageSecret = 4;
+    enum ResultType {
+        GENERAL_ERROR = 0;
+        SUCCESS = 1;
+        NOT_FOUND = 2;
+        DECRYPTION_ERROR = 3;
+    }
+}