@dcl/ecs
Version:
Decentraland ECS
1,336 lines (1,335 loc) • 71.5 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.GeneratedCodeInfo_Annotation = exports.GeneratedCodeInfo = exports.SourceCodeInfo_Location = exports.SourceCodeInfo = exports.UninterpretedOption_NamePart = exports.UninterpretedOption = exports.MethodOptions = exports.ServiceOptions = exports.EnumValueOptions = exports.EnumOptions = exports.OneofOptions = exports.FieldOptions = exports.MessageOptions = exports.FileOptions = exports.MethodDescriptorProto = exports.ServiceDescriptorProto = exports.EnumValueDescriptorProto = exports.EnumDescriptorProto = exports.OneofDescriptorProto = exports.FieldDescriptorProto = exports.DescriptorProto_ReservedRange = exports.DescriptorProto_ExtensionRange = exports.DescriptorProto = exports.FileDescriptorProto = exports.FileDescriptorSet = exports.FieldOptions_JSType = exports.FieldOptions_CType = exports.FileOptions_OptimizeMode = exports.FieldDescriptorProto_Label = exports.FieldDescriptorProto_Type = void 0;
/* eslint-disable */
const long_1 = __importDefault(require("long"));
const minimal_1 = __importDefault(require("protobufjs/minimal"));
const protobufPackageSarasa = "google.protobuf";
/**
* @public
*/
var FieldDescriptorProto_Type;
(function (FieldDescriptorProto_Type) {
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_DOUBLE"] = 1] = "TYPE_DOUBLE";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FLOAT"] = 2] = "TYPE_FLOAT";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_INT64"] = 3] = "TYPE_INT64";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_UINT64"] = 4] = "TYPE_UINT64";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_INT32"] = 5] = "TYPE_INT32";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FIXED64"] = 6] = "TYPE_FIXED64";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FIXED32"] = 7] = "TYPE_FIXED32";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_BOOL"] = 8] = "TYPE_BOOL";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_STRING"] = 9] = "TYPE_STRING";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_GROUP"] = 10] = "TYPE_GROUP";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_MESSAGE"] = 11] = "TYPE_MESSAGE";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_BYTES"] = 12] = "TYPE_BYTES";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_UINT32"] = 13] = "TYPE_UINT32";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_ENUM"] = 14] = "TYPE_ENUM";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SFIXED32"] = 15] = "TYPE_SFIXED32";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SFIXED64"] = 16] = "TYPE_SFIXED64";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SINT32"] = 17] = "TYPE_SINT32";
FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SINT64"] = 18] = "TYPE_SINT64";
})(FieldDescriptorProto_Type = exports.FieldDescriptorProto_Type || (exports.FieldDescriptorProto_Type = {}));
/**
* @public
*/
var FieldDescriptorProto_Label;
(function (FieldDescriptorProto_Label) {
FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_OPTIONAL"] = 1] = "LABEL_OPTIONAL";
FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_REQUIRED"] = 2] = "LABEL_REQUIRED";
FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_REPEATED"] = 3] = "LABEL_REPEATED";
})(FieldDescriptorProto_Label = exports.FieldDescriptorProto_Label || (exports.FieldDescriptorProto_Label = {}));
/**
* @public
*/
var FileOptions_OptimizeMode;
(function (FileOptions_OptimizeMode) {
FileOptions_OptimizeMode[FileOptions_OptimizeMode["SPEED"] = 1] = "SPEED";
FileOptions_OptimizeMode[FileOptions_OptimizeMode["CODE_SIZE"] = 2] = "CODE_SIZE";
FileOptions_OptimizeMode[FileOptions_OptimizeMode["LITE_RUNTIME"] = 3] = "LITE_RUNTIME";
})(FileOptions_OptimizeMode = exports.FileOptions_OptimizeMode || (exports.FileOptions_OptimizeMode = {}));
/**
* @public
*/
var FieldOptions_CType;
(function (FieldOptions_CType) {
FieldOptions_CType[FieldOptions_CType["STRING"] = 0] = "STRING";
FieldOptions_CType[FieldOptions_CType["CORD"] = 1] = "CORD";
FieldOptions_CType[FieldOptions_CType["STRING_PIECE"] = 2] = "STRING_PIECE";
})(FieldOptions_CType = exports.FieldOptions_CType || (exports.FieldOptions_CType = {}));
/**
* @public
*/
var FieldOptions_JSType;
(function (FieldOptions_JSType) {
FieldOptions_JSType[FieldOptions_JSType["JS_NORMAL"] = 0] = "JS_NORMAL";
FieldOptions_JSType[FieldOptions_JSType["JS_STRING"] = 1] = "JS_STRING";
FieldOptions_JSType[FieldOptions_JSType["JS_NUMBER"] = 2] = "JS_NUMBER";
})(FieldOptions_JSType = exports.FieldOptions_JSType || (exports.FieldOptions_JSType = {}));
function createBaseFileDescriptorSet() {
return { file: [] };
}
/**
* @public
*/
var FileDescriptorSet;
(function (FileDescriptorSet) {
function encode(message, writer = minimal_1.default.Writer.create()) {
for (const v of message.file) {
FileDescriptorProto.encode(v, writer.uint32(10).fork()).ldelim();
}
return writer;
}
FileDescriptorSet.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFileDescriptorSet();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.file.push(FileDescriptorProto.decode(reader, reader.uint32()));
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
FileDescriptorSet.decode = decode;
})(FileDescriptorSet = exports.FileDescriptorSet || (exports.FileDescriptorSet = {}));
function createBaseFileDescriptorProto() {
return {
name: "",
package: "",
dependency: [],
publicDependency: [],
weakDependency: [],
messageType: [],
enumType: [],
service: [],
extension: [],
options: undefined,
sourceCodeInfo: undefined,
syntax: "",
};
}
/**
* @public
*/
var FileDescriptorProto;
(function (FileDescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
if (message.package !== "") {
writer.uint32(18).string(message.package);
}
for (const v of message.dependency) {
writer.uint32(26).string(v);
}
writer.uint32(82).fork();
for (const v of message.publicDependency) {
writer.int32(v);
}
writer.ldelim();
writer.uint32(90).fork();
for (const v of message.weakDependency) {
writer.int32(v);
}
writer.ldelim();
for (const v of message.messageType) {
DescriptorProto.encode(v, writer.uint32(34).fork()).ldelim();
}
for (const v of message.enumType) {
EnumDescriptorProto.encode(v, writer.uint32(42).fork()).ldelim();
}
for (const v of message.service) {
ServiceDescriptorProto.encode(v, writer.uint32(50).fork()).ldelim();
}
for (const v of message.extension) {
FieldDescriptorProto.encode(v, writer.uint32(58).fork()).ldelim();
}
if (message.options !== undefined) {
FileOptions.encode(message.options, writer.uint32(66).fork()).ldelim();
}
if (message.sourceCodeInfo !== undefined) {
SourceCodeInfo.encode(message.sourceCodeInfo, writer.uint32(74).fork()).ldelim();
}
if (message.syntax !== "") {
writer.uint32(98).string(message.syntax);
}
return writer;
}
FileDescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFileDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 2:
if (tag !== 18) {
break;
}
message.package = reader.string();
continue;
case 3:
if (tag !== 26) {
break;
}
message.dependency.push(reader.string());
continue;
case 10:
if (tag === 80) {
message.publicDependency.push(reader.int32());
continue;
}
if (tag === 82) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.publicDependency.push(reader.int32());
}
continue;
}
break;
case 11:
if (tag === 88) {
message.weakDependency.push(reader.int32());
continue;
}
if (tag === 90) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.weakDependency.push(reader.int32());
}
continue;
}
break;
case 4:
if (tag !== 34) {
break;
}
message.messageType.push(DescriptorProto.decode(reader, reader.uint32()));
continue;
case 5:
if (tag !== 42) {
break;
}
message.enumType.push(EnumDescriptorProto.decode(reader, reader.uint32()));
continue;
case 6:
if (tag !== 50) {
break;
}
message.service.push(ServiceDescriptorProto.decode(reader, reader.uint32()));
continue;
case 7:
if (tag !== 58) {
break;
}
message.extension.push(FieldDescriptorProto.decode(reader, reader.uint32()));
continue;
case 8:
if (tag !== 66) {
break;
}
message.options = FileOptions.decode(reader, reader.uint32());
continue;
case 9:
if (tag !== 74) {
break;
}
message.sourceCodeInfo = SourceCodeInfo.decode(reader, reader.uint32());
continue;
case 12:
if (tag !== 98) {
break;
}
message.syntax = reader.string();
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
FileDescriptorProto.decode = decode;
})(FileDescriptorProto = exports.FileDescriptorProto || (exports.FileDescriptorProto = {}));
function createBaseDescriptorProto() {
return {
name: "",
field: [],
extension: [],
nestedType: [],
enumType: [],
extensionRange: [],
oneofDecl: [],
options: undefined,
reservedRange: [],
reservedName: [],
};
}
/**
* @public
*/
var DescriptorProto;
(function (DescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
for (const v of message.field) {
FieldDescriptorProto.encode(v, writer.uint32(18).fork()).ldelim();
}
for (const v of message.extension) {
FieldDescriptorProto.encode(v, writer.uint32(50).fork()).ldelim();
}
for (const v of message.nestedType) {
DescriptorProto.encode(v, writer.uint32(26).fork()).ldelim();
}
for (const v of message.enumType) {
EnumDescriptorProto.encode(v, writer.uint32(34).fork()).ldelim();
}
for (const v of message.extensionRange) {
DescriptorProto_ExtensionRange.encode(v, writer.uint32(42).fork()).ldelim();
}
for (const v of message.oneofDecl) {
OneofDescriptorProto.encode(v, writer.uint32(66).fork()).ldelim();
}
if (message.options !== undefined) {
MessageOptions.encode(message.options, writer.uint32(58).fork()).ldelim();
}
for (const v of message.reservedRange) {
DescriptorProto_ReservedRange.encode(v, writer.uint32(74).fork()).ldelim();
}
for (const v of message.reservedName) {
writer.uint32(82).string(v);
}
return writer;
}
DescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 2:
if (tag !== 18) {
break;
}
message.field.push(FieldDescriptorProto.decode(reader, reader.uint32()));
continue;
case 6:
if (tag !== 50) {
break;
}
message.extension.push(FieldDescriptorProto.decode(reader, reader.uint32()));
continue;
case 3:
if (tag !== 26) {
break;
}
message.nestedType.push(DescriptorProto.decode(reader, reader.uint32()));
continue;
case 4:
if (tag !== 34) {
break;
}
message.enumType.push(EnumDescriptorProto.decode(reader, reader.uint32()));
continue;
case 5:
if (tag !== 42) {
break;
}
message.extensionRange.push(DescriptorProto_ExtensionRange.decode(reader, reader.uint32()));
continue;
case 8:
if (tag !== 66) {
break;
}
message.oneofDecl.push(OneofDescriptorProto.decode(reader, reader.uint32()));
continue;
case 7:
if (tag !== 58) {
break;
}
message.options = MessageOptions.decode(reader, reader.uint32());
continue;
case 9:
if (tag !== 74) {
break;
}
message.reservedRange.push(DescriptorProto_ReservedRange.decode(reader, reader.uint32()));
continue;
case 10:
if (tag !== 82) {
break;
}
message.reservedName.push(reader.string());
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
DescriptorProto.decode = decode;
})(DescriptorProto = exports.DescriptorProto || (exports.DescriptorProto = {}));
function createBaseDescriptorProto_ExtensionRange() {
return { start: 0, end: 0 };
}
/**
* @public
*/
var DescriptorProto_ExtensionRange;
(function (DescriptorProto_ExtensionRange) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.start !== 0) {
writer.uint32(8).int32(message.start);
}
if (message.end !== 0) {
writer.uint32(16).int32(message.end);
}
return writer;
}
DescriptorProto_ExtensionRange.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseDescriptorProto_ExtensionRange();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 8) {
break;
}
message.start = reader.int32();
continue;
case 2:
if (tag !== 16) {
break;
}
message.end = reader.int32();
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
DescriptorProto_ExtensionRange.decode = decode;
})(DescriptorProto_ExtensionRange = exports.DescriptorProto_ExtensionRange || (exports.DescriptorProto_ExtensionRange = {}));
function createBaseDescriptorProto_ReservedRange() {
return { start: 0, end: 0 };
}
/**
* @public
*/
var DescriptorProto_ReservedRange;
(function (DescriptorProto_ReservedRange) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.start !== 0) {
writer.uint32(8).int32(message.start);
}
if (message.end !== 0) {
writer.uint32(16).int32(message.end);
}
return writer;
}
DescriptorProto_ReservedRange.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseDescriptorProto_ReservedRange();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 8) {
break;
}
message.start = reader.int32();
continue;
case 2:
if (tag !== 16) {
break;
}
message.end = reader.int32();
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
DescriptorProto_ReservedRange.decode = decode;
})(DescriptorProto_ReservedRange = exports.DescriptorProto_ReservedRange || (exports.DescriptorProto_ReservedRange = {}));
function createBaseFieldDescriptorProto() {
return {
name: "",
number: 0,
label: 1,
type: 1,
typeName: "",
extendee: "",
defaultValue: "",
oneofIndex: 0,
jsonName: "",
options: undefined,
};
}
/**
* @public
*/
var FieldDescriptorProto;
(function (FieldDescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
if (message.number !== 0) {
writer.uint32(24).int32(message.number);
}
if (message.label !== 1) {
writer.uint32(32).int32(message.label);
}
if (message.type !== 1) {
writer.uint32(40).int32(message.type);
}
if (message.typeName !== "") {
writer.uint32(50).string(message.typeName);
}
if (message.extendee !== "") {
writer.uint32(18).string(message.extendee);
}
if (message.defaultValue !== "") {
writer.uint32(58).string(message.defaultValue);
}
if (message.oneofIndex !== 0) {
writer.uint32(72).int32(message.oneofIndex);
}
if (message.jsonName !== "") {
writer.uint32(82).string(message.jsonName);
}
if (message.options !== undefined) {
FieldOptions.encode(message.options, writer.uint32(66).fork()).ldelim();
}
return writer;
}
FieldDescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFieldDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 3:
if (tag !== 24) {
break;
}
message.number = reader.int32();
continue;
case 4:
if (tag !== 32) {
break;
}
message.label = reader.int32();
continue;
case 5:
if (tag !== 40) {
break;
}
message.type = reader.int32();
continue;
case 6:
if (tag !== 50) {
break;
}
message.typeName = reader.string();
continue;
case 2:
if (tag !== 18) {
break;
}
message.extendee = reader.string();
continue;
case 7:
if (tag !== 58) {
break;
}
message.defaultValue = reader.string();
continue;
case 9:
if (tag !== 72) {
break;
}
message.oneofIndex = reader.int32();
continue;
case 10:
if (tag !== 82) {
break;
}
message.jsonName = reader.string();
continue;
case 8:
if (tag !== 66) {
break;
}
message.options = FieldOptions.decode(reader, reader.uint32());
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
FieldDescriptorProto.decode = decode;
})(FieldDescriptorProto = exports.FieldDescriptorProto || (exports.FieldDescriptorProto = {}));
function createBaseOneofDescriptorProto() {
return { name: "", options: undefined };
}
/**
* @public
*/
var OneofDescriptorProto;
(function (OneofDescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
if (message.options !== undefined) {
OneofOptions.encode(message.options, writer.uint32(18).fork()).ldelim();
}
return writer;
}
OneofDescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseOneofDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 2:
if (tag !== 18) {
break;
}
message.options = OneofOptions.decode(reader, reader.uint32());
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
OneofDescriptorProto.decode = decode;
})(OneofDescriptorProto = exports.OneofDescriptorProto || (exports.OneofDescriptorProto = {}));
function createBaseEnumDescriptorProto() {
return { name: "", value: [], options: undefined };
}
/**
* @public
*/
var EnumDescriptorProto;
(function (EnumDescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
for (const v of message.value) {
EnumValueDescriptorProto.encode(v, writer.uint32(18).fork()).ldelim();
}
if (message.options !== undefined) {
EnumOptions.encode(message.options, writer.uint32(26).fork()).ldelim();
}
return writer;
}
EnumDescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseEnumDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 2:
if (tag !== 18) {
break;
}
message.value.push(EnumValueDescriptorProto.decode(reader, reader.uint32()));
continue;
case 3:
if (tag !== 26) {
break;
}
message.options = EnumOptions.decode(reader, reader.uint32());
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
EnumDescriptorProto.decode = decode;
})(EnumDescriptorProto = exports.EnumDescriptorProto || (exports.EnumDescriptorProto = {}));
function createBaseEnumValueDescriptorProto() {
return { name: "", number: 0, options: undefined };
}
/**
* @public
*/
var EnumValueDescriptorProto;
(function (EnumValueDescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
if (message.number !== 0) {
writer.uint32(16).int32(message.number);
}
if (message.options !== undefined) {
EnumValueOptions.encode(message.options, writer.uint32(26).fork()).ldelim();
}
return writer;
}
EnumValueDescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseEnumValueDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 2:
if (tag !== 16) {
break;
}
message.number = reader.int32();
continue;
case 3:
if (tag !== 26) {
break;
}
message.options = EnumValueOptions.decode(reader, reader.uint32());
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
EnumValueDescriptorProto.decode = decode;
})(EnumValueDescriptorProto = exports.EnumValueDescriptorProto || (exports.EnumValueDescriptorProto = {}));
function createBaseServiceDescriptorProto() {
return { name: "", method: [], options: undefined };
}
/**
* @public
*/
var ServiceDescriptorProto;
(function (ServiceDescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
for (const v of message.method) {
MethodDescriptorProto.encode(v, writer.uint32(18).fork()).ldelim();
}
if (message.options !== undefined) {
ServiceOptions.encode(message.options, writer.uint32(26).fork()).ldelim();
}
return writer;
}
ServiceDescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseServiceDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 2:
if (tag !== 18) {
break;
}
message.method.push(MethodDescriptorProto.decode(reader, reader.uint32()));
continue;
case 3:
if (tag !== 26) {
break;
}
message.options = ServiceOptions.decode(reader, reader.uint32());
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
ServiceDescriptorProto.decode = decode;
})(ServiceDescriptorProto = exports.ServiceDescriptorProto || (exports.ServiceDescriptorProto = {}));
function createBaseMethodDescriptorProto() {
return {
name: "",
inputType: "",
outputType: "",
options: undefined,
clientStreaming: false,
serverStreaming: false,
};
}
/**
* @public
*/
var MethodDescriptorProto;
(function (MethodDescriptorProto) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.name !== "") {
writer.uint32(10).string(message.name);
}
if (message.inputType !== "") {
writer.uint32(18).string(message.inputType);
}
if (message.outputType !== "") {
writer.uint32(26).string(message.outputType);
}
if (message.options !== undefined) {
MethodOptions.encode(message.options, writer.uint32(34).fork()).ldelim();
}
if (message.clientStreaming === true) {
writer.uint32(40).bool(message.clientStreaming);
}
if (message.serverStreaming === true) {
writer.uint32(48).bool(message.serverStreaming);
}
return writer;
}
MethodDescriptorProto.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMethodDescriptorProto();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.name = reader.string();
continue;
case 2:
if (tag !== 18) {
break;
}
message.inputType = reader.string();
continue;
case 3:
if (tag !== 26) {
break;
}
message.outputType = reader.string();
continue;
case 4:
if (tag !== 34) {
break;
}
message.options = MethodOptions.decode(reader, reader.uint32());
continue;
case 5:
if (tag !== 40) {
break;
}
message.clientStreaming = reader.bool();
continue;
case 6:
if (tag !== 48) {
break;
}
message.serverStreaming = reader.bool();
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
MethodDescriptorProto.decode = decode;
})(MethodDescriptorProto = exports.MethodDescriptorProto || (exports.MethodDescriptorProto = {}));
function createBaseFileOptions() {
return {
javaPackage: "",
javaOuterClassname: "",
javaMultipleFiles: false,
javaGenerateEqualsAndHash: false,
javaStringCheckUtf8: false,
optimizeFor: 1,
goPackage: "",
ccGenericServices: false,
javaGenericServices: false,
pyGenericServices: false,
deprecated: false,
ccEnableArenas: false,
objcClassPrefix: "",
csharpNamespace: "",
uninterpretedOption: [],
};
}
/**
* @public
*/
var FileOptions;
(function (FileOptions) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.javaPackage !== "") {
writer.uint32(10).string(message.javaPackage);
}
if (message.javaOuterClassname !== "") {
writer.uint32(66).string(message.javaOuterClassname);
}
if (message.javaMultipleFiles === true) {
writer.uint32(80).bool(message.javaMultipleFiles);
}
if (message.javaGenerateEqualsAndHash === true) {
writer.uint32(160).bool(message.javaGenerateEqualsAndHash);
}
if (message.javaStringCheckUtf8 === true) {
writer.uint32(216).bool(message.javaStringCheckUtf8);
}
if (message.optimizeFor !== 1) {
writer.uint32(72).int32(message.optimizeFor);
}
if (message.goPackage !== "") {
writer.uint32(90).string(message.goPackage);
}
if (message.ccGenericServices === true) {
writer.uint32(128).bool(message.ccGenericServices);
}
if (message.javaGenericServices === true) {
writer.uint32(136).bool(message.javaGenericServices);
}
if (message.pyGenericServices === true) {
writer.uint32(144).bool(message.pyGenericServices);
}
if (message.deprecated === true) {
writer.uint32(184).bool(message.deprecated);
}
if (message.ccEnableArenas === true) {
writer.uint32(248).bool(message.ccEnableArenas);
}
if (message.objcClassPrefix !== "") {
writer.uint32(290).string(message.objcClassPrefix);
}
if (message.csharpNamespace !== "") {
writer.uint32(298).string(message.csharpNamespace);
}
for (const v of message.uninterpretedOption) {
UninterpretedOption.encode(v, writer.uint32(7994).fork()).ldelim();
}
return writer;
}
FileOptions.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFileOptions();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 10) {
break;
}
message.javaPackage = reader.string();
continue;
case 8:
if (tag !== 66) {
break;
}
message.javaOuterClassname = reader.string();
continue;
case 10:
if (tag !== 80) {
break;
}
message.javaMultipleFiles = reader.bool();
continue;
case 20:
if (tag !== 160) {
break;
}
message.javaGenerateEqualsAndHash = reader.bool();
continue;
case 27:
if (tag !== 216) {
break;
}
message.javaStringCheckUtf8 = reader.bool();
continue;
case 9:
if (tag !== 72) {
break;
}
message.optimizeFor = reader.int32();
continue;
case 11:
if (tag !== 90) {
break;
}
message.goPackage = reader.string();
continue;
case 16:
if (tag !== 128) {
break;
}
message.ccGenericServices = reader.bool();
continue;
case 17:
if (tag !== 136) {
break;
}
message.javaGenericServices = reader.bool();
continue;
case 18:
if (tag !== 144) {
break;
}
message.pyGenericServices = reader.bool();
continue;
case 23:
if (tag !== 184) {
break;
}
message.deprecated = reader.bool();
continue;
case 31:
if (tag !== 248) {
break;
}
message.ccEnableArenas = reader.bool();
continue;
case 36:
if (tag !== 290) {
break;
}
message.objcClassPrefix = reader.string();
continue;
case 37:
if (tag !== 298) {
break;
}
message.csharpNamespace = reader.string();
continue;
case 999:
if (tag !== 7994) {
break;
}
message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
FileOptions.decode = decode;
})(FileOptions = exports.FileOptions || (exports.FileOptions = {}));
function createBaseMessageOptions() {
return {
messageSetWireFormat: false,
noStandardDescriptorAccessor: false,
deprecated: false,
mapEntry: false,
uninterpretedOption: [],
};
}
/**
* @public
*/
var MessageOptions;
(function (MessageOptions) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.messageSetWireFormat === true) {
writer.uint32(8).bool(message.messageSetWireFormat);
}
if (message.noStandardDescriptorAccessor === true) {
writer.uint32(16).bool(message.noStandardDescriptorAccessor);
}
if (message.deprecated === true) {
writer.uint32(24).bool(message.deprecated);
}
if (message.mapEntry === true) {
writer.uint32(56).bool(message.mapEntry);
}
for (const v of message.uninterpretedOption) {
UninterpretedOption.encode(v, writer.uint32(7994).fork()).ldelim();
}
return writer;
}
MessageOptions.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMessageOptions();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 8) {
break;
}
message.messageSetWireFormat = reader.bool();
continue;
case 2:
if (tag !== 16) {
break;
}
message.noStandardDescriptorAccessor = reader.bool();
continue;
case 3:
if (tag !== 24) {
break;
}
message.deprecated = reader.bool();
continue;
case 7:
if (tag !== 56) {
break;
}
message.mapEntry = reader.bool();
continue;
case 999:
if (tag !== 7994) {
break;
}
message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
MessageOptions.decode = decode;
})(MessageOptions = exports.MessageOptions || (exports.MessageOptions = {}));
function createBaseFieldOptions() {
return { ctype: 0, packed: false, jstype: 0, lazy: false, deprecated: false, weak: false, uninterpretedOption: [] };
}
/**
* @public
*/
var FieldOptions;
(function (FieldOptions) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.ctype !== 0) {
writer.uint32(8).int32(message.ctype);
}
if (message.packed === true) {
writer.uint32(16).bool(message.packed);
}
if (message.jstype !== 0) {
writer.uint32(48).int32(message.jstype);
}
if (message.lazy === true) {
writer.uint32(40).bool(message.lazy);
}
if (message.deprecated === true) {
writer.uint32(24).bool(message.deprecated);
}
if (message.weak === true) {
writer.uint32(80).bool(message.weak);
}
for (const v of message.uninterpretedOption) {
UninterpretedOption.encode(v, writer.uint32(7994).fork()).ldelim();
}
return writer;
}
FieldOptions.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFieldOptions();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1:
if (tag !== 8) {
break;
}
message.ctype = reader.int32();
continue;
case 2:
if (tag !== 16) {
break;
}
message.packed = reader.bool();
continue;
case 6:
if (tag !== 48) {
break;
}
message.jstype = reader.int32();
continue;
case 5:
if (tag !== 40) {
break;
}
message.lazy = reader.bool();
continue;
case 3:
if (tag !== 24) {
break;
}
message.deprecated = reader.bool();
continue;
case 10:
if (tag !== 80) {
break;
}
message.weak = reader.bool();
continue;
case 999:
if (tag !== 7994) {
break;
}
message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
FieldOptions.decode = decode;
})(FieldOptions = exports.FieldOptions || (exports.FieldOptions = {}));
function createBaseOneofOptions() {
return { uninterpretedOption: [] };
}
/**
* @public
*/
var OneofOptions;
(function (OneofOptions) {
function encode(message, writer = minimal_1.default.Writer.create()) {
for (const v of message.uninterpretedOption) {
UninterpretedOption.encode(v, writer.uint32(7994).fork()).ldelim();
}
return writer;
}
OneofOptions.encode = encode;
function decode(input, length) {
const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
let end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseOneofOptions();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 999:
if (tag !== 7994) {
break;
}
message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
continue;
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skipType(tag & 7);
}
return message;
}
OneofOptions.decode = decode;
})(OneofOptions = exports.OneofOptions || (exports.OneofOptions = {}));
function createBaseEnumOptions() {
return { allowAlias: false, deprecated: false, uninterpretedOption: [] };
}
/**
* @public
*/
var EnumOptions;
(function (EnumOptions) {
function encode(message, writer = minimal_1.default.Writer.create()) {
if (message.allowAlias === true) {