@fatehan/tsrp 1.6.16 → 1.6.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (88) hide show
  1. package/package.json +1 -1
  2. package/dist/fatehan/activities/workflow.d.ts +0 -219
  3. package/dist/fatehan/activities/workflow.d.ts.map +0 -1
  4. package/dist/fatehan/activities/workflow.js +0 -1941
  5. package/dist/fatehan/activities/workshift.d.ts +0 -140
  6. package/dist/fatehan/activities/workshift.d.ts.map +0 -1
  7. package/dist/fatehan/activities/workshift.js +0 -1244
  8. package/dist/fatehan/apis/client.d.ts +0 -246
  9. package/dist/fatehan/apis/client.d.ts.map +0 -1
  10. package/dist/fatehan/apis/client.js +0 -2572
  11. package/dist/fatehan/areas/area.d.ts +0 -96
  12. package/dist/fatehan/areas/area.d.ts.map +0 -1
  13. package/dist/fatehan/areas/area.js +0 -761
  14. package/dist/fatehan/devices/devices.d.ts +0 -256
  15. package/dist/fatehan/devices/devices.d.ts.map +0 -1
  16. package/dist/fatehan/devices/devices.js +0 -2730
  17. package/dist/fatehan/devices/maintenance.d.ts +0 -64
  18. package/dist/fatehan/devices/maintenance.d.ts.map +0 -1
  19. package/dist/fatehan/devices/maintenance.js +0 -484
  20. package/dist/fatehan/financial/financial.d.ts +0 -162
  21. package/dist/fatehan/financial/financial.d.ts.map +0 -1
  22. package/dist/fatehan/financial/financial.js +0 -1701
  23. package/dist/fatehan/google/protobuf/descriptor.d.ts +0 -1303
  24. package/dist/fatehan/google/protobuf/descriptor.d.ts.map +0 -1
  25. package/dist/fatehan/google/protobuf/descriptor.js +0 -3467
  26. package/dist/fatehan/google/protobuf/duration.d.ts +0 -99
  27. package/dist/fatehan/google/protobuf/duration.d.ts.map +0 -1
  28. package/dist/fatehan/google/protobuf/duration.js +0 -63
  29. package/dist/fatehan/google/protobuf/field_mask.d.ts +0 -228
  30. package/dist/fatehan/google/protobuf/field_mask.d.ts.map +0 -1
  31. package/dist/fatehan/google/protobuf/field_mask.js +0 -57
  32. package/dist/fatehan/google/protobuf/timestamp.d.ts +0 -129
  33. package/dist/fatehan/google/protobuf/timestamp.d.ts.map +0 -1
  34. package/dist/fatehan/google/protobuf/timestamp.js +0 -63
  35. package/dist/fatehan/identities/authentication.d.ts +0 -164
  36. package/dist/fatehan/identities/authentication.d.ts.map +0 -1
  37. package/dist/fatehan/identities/authentication.js +0 -1291
  38. package/dist/fatehan/identities/identities.d.ts +0 -969
  39. package/dist/fatehan/identities/identities.d.ts.map +0 -1
  40. package/dist/fatehan/identities/identities.js +0 -2993
  41. package/dist/fatehan/models/fusion.d.ts +0 -149
  42. package/dist/fatehan/models/fusion.d.ts.map +0 -1
  43. package/dist/fatehan/models/fusion.js +0 -1531
  44. package/dist/fatehan/models/models.d.ts +0 -162
  45. package/dist/fatehan/models/models.d.ts.map +0 -1
  46. package/dist/fatehan/models/models.js +0 -1486
  47. package/dist/fatehan/notifies/direct.d.ts +0 -85
  48. package/dist/fatehan/notifies/direct.d.ts.map +0 -1
  49. package/dist/fatehan/notifies/direct.js +0 -669
  50. package/dist/fatehan/notifies/notify.d.ts +0 -232
  51. package/dist/fatehan/notifies/notify.d.ts.map +0 -1
  52. package/dist/fatehan/notifies/notify.js +0 -1958
  53. package/dist/fatehan/packets/commands.d.ts +0 -150
  54. package/dist/fatehan/packets/commands.d.ts.map +0 -1
  55. package/dist/fatehan/packets/commands.js +0 -1364
  56. package/dist/fatehan/packets/dataModel.d.ts +0 -1610
  57. package/dist/fatehan/packets/dataModel.d.ts.map +0 -1
  58. package/dist/fatehan/packets/dataModel.js +0 -14947
  59. package/dist/fatehan/packets/dataModule.d.ts +0 -61
  60. package/dist/fatehan/packets/dataModule.d.ts.map +0 -1
  61. package/dist/fatehan/packets/dataModule.js +0 -386
  62. package/dist/fatehan/packets/forge.d.ts +0 -142
  63. package/dist/fatehan/packets/forge.d.ts.map +0 -1
  64. package/dist/fatehan/packets/forge.js +0 -1339
  65. package/dist/fatehan/services/api.d.ts +0 -1207
  66. package/dist/fatehan/services/api.d.ts.map +0 -1
  67. package/dist/fatehan/services/api.js +0 -12492
  68. package/dist/fatehan/services/repositories.d.ts +0 -78
  69. package/dist/fatehan/services/repositories.d.ts.map +0 -1
  70. package/dist/fatehan/services/repositories.js +0 -620
  71. package/dist/fatehan/stream/stream.d.ts +0 -224
  72. package/dist/fatehan/stream/stream.d.ts.map +0 -1
  73. package/dist/fatehan/stream/stream.js +0 -1416
  74. package/dist/fatehan/trips/trip.d.ts +0 -325
  75. package/dist/fatehan/trips/trip.d.ts.map +0 -1
  76. package/dist/fatehan/trips/trip.js +0 -1635
  77. package/dist/fatehan/utils/buf/validate/validate.d.ts +0 -3520
  78. package/dist/fatehan/utils/buf/validate/validate.d.ts.map +0 -1
  79. package/dist/fatehan/utils/buf/validate/validate.js +0 -4248
  80. package/dist/services.d.ts +0 -78
  81. package/dist/services.d.ts.map +0 -1
  82. package/dist/services.js +0 -242
  83. package/dist/store/system.io.d.ts +0 -6
  84. package/dist/store/system.io.d.ts.map +0 -1
  85. package/dist/store/system.io.js +0 -14
  86. package/dist/system.io.d.ts +0 -6
  87. package/dist/system.io.d.ts.map +0 -1
  88. package/dist/system.io.js +0 -208
@@ -1,3467 +0,0 @@
1
- // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
2
- // versions:
3
- // protoc-gen-ts_proto v2.11.6
4
- // protoc v7.34.1
5
- // source: google/protobuf/descriptor.proto
6
- /* eslint-disable */
7
- import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
8
- import Long from "long";
9
- export const protobufPackage = "google.protobuf";
10
- /** The full set of known editions. */
11
- export var Edition;
12
- (function (Edition) {
13
- /** EDITION_UNKNOWN - A placeholder for an unknown edition value. */
14
- Edition[Edition["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN";
15
- /**
16
- * EDITION_LEGACY - A placeholder edition for specifying default behaviors *before* a feature
17
- * was first introduced. This is effectively an "infinite past".
18
- */
19
- Edition[Edition["EDITION_LEGACY"] = 900] = "EDITION_LEGACY";
20
- /**
21
- * EDITION_PROTO2 - Legacy syntax "editions". These pre-date editions, but behave much like
22
- * distinct editions. These can't be used to specify the edition of proto
23
- * files, but feature definitions must supply proto2/proto3 defaults for
24
- * backwards compatibility.
25
- */
26
- Edition[Edition["EDITION_PROTO2"] = 998] = "EDITION_PROTO2";
27
- Edition[Edition["EDITION_PROTO3"] = 999] = "EDITION_PROTO3";
28
- /**
29
- * EDITION_2023 - Editions that have been released. The specific values are arbitrary and
30
- * should not be depended on, but they will always be time-ordered for easy
31
- * comparison.
32
- */
33
- Edition[Edition["EDITION_2023"] = 1000] = "EDITION_2023";
34
- Edition[Edition["EDITION_2024"] = 1001] = "EDITION_2024";
35
- /** EDITION_UNSTABLE - A placeholder edition for developing and testing unscheduled features. */
36
- Edition[Edition["EDITION_UNSTABLE"] = 9999] = "EDITION_UNSTABLE";
37
- /**
38
- * EDITION_1_TEST_ONLY - Placeholder editions for testing feature resolution. These should not be
39
- * used or relied on outside of tests.
40
- */
41
- Edition[Edition["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY";
42
- Edition[Edition["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY";
43
- Edition[Edition["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY";
44
- Edition[Edition["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY";
45
- Edition[Edition["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY";
46
- /**
47
- * EDITION_MAX - Placeholder for specifying unbounded edition support. This should only
48
- * ever be used by plugins that can expect to never require any changes to
49
- * support a new edition.
50
- */
51
- Edition[Edition["EDITION_MAX"] = 2147483647] = "EDITION_MAX";
52
- Edition[Edition["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
53
- })(Edition || (Edition = {}));
54
- /**
55
- * Describes the 'visibility' of a symbol with respect to the proto import
56
- * system. Symbols can only be imported when the visibility rules do not prevent
57
- * it (ex: local symbols cannot be imported). Visibility modifiers can only set
58
- * on `message` and `enum` as they are the only types available to be referenced
59
- * from other files.
60
- */
61
- export var SymbolVisibility;
62
- (function (SymbolVisibility) {
63
- SymbolVisibility[SymbolVisibility["VISIBILITY_UNSET"] = 0] = "VISIBILITY_UNSET";
64
- SymbolVisibility[SymbolVisibility["VISIBILITY_LOCAL"] = 1] = "VISIBILITY_LOCAL";
65
- SymbolVisibility[SymbolVisibility["VISIBILITY_EXPORT"] = 2] = "VISIBILITY_EXPORT";
66
- SymbolVisibility[SymbolVisibility["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
67
- })(SymbolVisibility || (SymbolVisibility = {}));
68
- /** The verification state of the extension range. */
69
- export var ExtensionRangeOptions_VerificationState;
70
- (function (ExtensionRangeOptions_VerificationState) {
71
- /** DECLARATION - All the extensions of the range must be declared. */
72
- ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["DECLARATION"] = 0] = "DECLARATION";
73
- ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["UNVERIFIED"] = 1] = "UNVERIFIED";
74
- ExtensionRangeOptions_VerificationState[ExtensionRangeOptions_VerificationState["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
75
- })(ExtensionRangeOptions_VerificationState || (ExtensionRangeOptions_VerificationState = {}));
76
- export var FieldDescriptorProto_Type;
77
- (function (FieldDescriptorProto_Type) {
78
- /**
79
- * TYPE_DOUBLE - 0 is reserved for errors.
80
- * Order is weird for historical reasons.
81
- */
82
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_DOUBLE"] = 1] = "TYPE_DOUBLE";
83
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FLOAT"] = 2] = "TYPE_FLOAT";
84
- /**
85
- * TYPE_INT64 - Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
86
- * negative values are likely.
87
- */
88
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_INT64"] = 3] = "TYPE_INT64";
89
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_UINT64"] = 4] = "TYPE_UINT64";
90
- /**
91
- * TYPE_INT32 - Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
92
- * negative values are likely.
93
- */
94
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_INT32"] = 5] = "TYPE_INT32";
95
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FIXED64"] = 6] = "TYPE_FIXED64";
96
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_FIXED32"] = 7] = "TYPE_FIXED32";
97
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_BOOL"] = 8] = "TYPE_BOOL";
98
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_STRING"] = 9] = "TYPE_STRING";
99
- /**
100
- * TYPE_GROUP - Tag-delimited aggregate.
101
- * Group type is deprecated and not supported after google.protobuf. However, Proto3
102
- * implementations should still be able to parse the group wire format and
103
- * treat group fields as unknown fields. In Editions, the group wire format
104
- * can be enabled via the `message_encoding` feature.
105
- */
106
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_GROUP"] = 10] = "TYPE_GROUP";
107
- /** TYPE_MESSAGE - Length-delimited aggregate. */
108
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_MESSAGE"] = 11] = "TYPE_MESSAGE";
109
- /** TYPE_BYTES - New in version 2. */
110
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_BYTES"] = 12] = "TYPE_BYTES";
111
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_UINT32"] = 13] = "TYPE_UINT32";
112
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_ENUM"] = 14] = "TYPE_ENUM";
113
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SFIXED32"] = 15] = "TYPE_SFIXED32";
114
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SFIXED64"] = 16] = "TYPE_SFIXED64";
115
- /** TYPE_SINT32 - Uses ZigZag encoding. */
116
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SINT32"] = 17] = "TYPE_SINT32";
117
- /** TYPE_SINT64 - Uses ZigZag encoding. */
118
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["TYPE_SINT64"] = 18] = "TYPE_SINT64";
119
- FieldDescriptorProto_Type[FieldDescriptorProto_Type["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
120
- })(FieldDescriptorProto_Type || (FieldDescriptorProto_Type = {}));
121
- export var FieldDescriptorProto_Label;
122
- (function (FieldDescriptorProto_Label) {
123
- /** LABEL_OPTIONAL - 0 is reserved for errors */
124
- FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_OPTIONAL"] = 1] = "LABEL_OPTIONAL";
125
- FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_REPEATED"] = 3] = "LABEL_REPEATED";
126
- /**
127
- * LABEL_REQUIRED - The required label is only allowed in google.protobuf. In proto3 and Editions
128
- * it's explicitly prohibited. In Editions, the `field_presence` feature
129
- * can be used to get this behavior.
130
- */
131
- FieldDescriptorProto_Label[FieldDescriptorProto_Label["LABEL_REQUIRED"] = 2] = "LABEL_REQUIRED";
132
- FieldDescriptorProto_Label[FieldDescriptorProto_Label["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
133
- })(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {}));
134
- /** Generated classes can be optimized for speed or code size. */
135
- export var FileOptions_OptimizeMode;
136
- (function (FileOptions_OptimizeMode) {
137
- /** SPEED - Generate complete code for parsing, serialization, */
138
- FileOptions_OptimizeMode[FileOptions_OptimizeMode["SPEED"] = 1] = "SPEED";
139
- /** CODE_SIZE - etc. */
140
- FileOptions_OptimizeMode[FileOptions_OptimizeMode["CODE_SIZE"] = 2] = "CODE_SIZE";
141
- /** LITE_RUNTIME - Generate code using MessageLite and the lite runtime. */
142
- FileOptions_OptimizeMode[FileOptions_OptimizeMode["LITE_RUNTIME"] = 3] = "LITE_RUNTIME";
143
- FileOptions_OptimizeMode[FileOptions_OptimizeMode["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
144
- })(FileOptions_OptimizeMode || (FileOptions_OptimizeMode = {}));
145
- export var FieldOptions_CType;
146
- (function (FieldOptions_CType) {
147
- /** STRING - Default mode. */
148
- FieldOptions_CType[FieldOptions_CType["STRING"] = 0] = "STRING";
149
- /**
150
- * CORD - The option [ctype=CORD] may be applied to a non-repeated field of type
151
- * "bytes". It indicates that in C++, the data should be stored in a Cord
152
- * instead of a string. For very large strings, this may reduce memory
153
- * fragmentation. It may also allow better performance when parsing from a
154
- * Cord, or when parsing with aliasing enabled, as the parsed Cord may then
155
- * alias the original buffer.
156
- */
157
- FieldOptions_CType[FieldOptions_CType["CORD"] = 1] = "CORD";
158
- FieldOptions_CType[FieldOptions_CType["STRING_PIECE"] = 2] = "STRING_PIECE";
159
- FieldOptions_CType[FieldOptions_CType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
160
- })(FieldOptions_CType || (FieldOptions_CType = {}));
161
- export var FieldOptions_JSType;
162
- (function (FieldOptions_JSType) {
163
- /** JS_NORMAL - Use the default type. */
164
- FieldOptions_JSType[FieldOptions_JSType["JS_NORMAL"] = 0] = "JS_NORMAL";
165
- /** JS_STRING - Use JavaScript strings. */
166
- FieldOptions_JSType[FieldOptions_JSType["JS_STRING"] = 1] = "JS_STRING";
167
- /** JS_NUMBER - Use JavaScript numbers. */
168
- FieldOptions_JSType[FieldOptions_JSType["JS_NUMBER"] = 2] = "JS_NUMBER";
169
- FieldOptions_JSType[FieldOptions_JSType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
170
- })(FieldOptions_JSType || (FieldOptions_JSType = {}));
171
- /** If set to RETENTION_SOURCE, the option will be omitted from the binary. */
172
- export var FieldOptions_OptionRetention;
173
- (function (FieldOptions_OptionRetention) {
174
- FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_UNKNOWN"] = 0] = "RETENTION_UNKNOWN";
175
- FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_RUNTIME"] = 1] = "RETENTION_RUNTIME";
176
- FieldOptions_OptionRetention[FieldOptions_OptionRetention["RETENTION_SOURCE"] = 2] = "RETENTION_SOURCE";
177
- FieldOptions_OptionRetention[FieldOptions_OptionRetention["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
178
- })(FieldOptions_OptionRetention || (FieldOptions_OptionRetention = {}));
179
- /**
180
- * This indicates the types of entities that the field may apply to when used
181
- * as an option. If it is unset, then the field may be freely used as an
182
- * option on any kind of entity.
183
- */
184
- export var FieldOptions_OptionTargetType;
185
- (function (FieldOptions_OptionTargetType) {
186
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_UNKNOWN"] = 0] = "TARGET_TYPE_UNKNOWN";
187
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FILE"] = 1] = "TARGET_TYPE_FILE";
188
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_EXTENSION_RANGE"] = 2] = "TARGET_TYPE_EXTENSION_RANGE";
189
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_MESSAGE"] = 3] = "TARGET_TYPE_MESSAGE";
190
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_FIELD"] = 4] = "TARGET_TYPE_FIELD";
191
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ONEOF"] = 5] = "TARGET_TYPE_ONEOF";
192
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM"] = 6] = "TARGET_TYPE_ENUM";
193
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_ENUM_ENTRY"] = 7] = "TARGET_TYPE_ENUM_ENTRY";
194
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_SERVICE"] = 8] = "TARGET_TYPE_SERVICE";
195
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["TARGET_TYPE_METHOD"] = 9] = "TARGET_TYPE_METHOD";
196
- FieldOptions_OptionTargetType[FieldOptions_OptionTargetType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
197
- })(FieldOptions_OptionTargetType || (FieldOptions_OptionTargetType = {}));
198
- /**
199
- * Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
200
- * or neither? HTTP based RPC implementation may choose GET verb for safe
201
- * methods, and PUT verb for idempotent methods instead of the default POST.
202
- */
203
- export var MethodOptions_IdempotencyLevel;
204
- (function (MethodOptions_IdempotencyLevel) {
205
- MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN";
206
- /** NO_SIDE_EFFECTS - implies idempotent */
207
- MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS";
208
- /** IDEMPOTENT - idempotent, but may have side effects */
209
- MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["IDEMPOTENT"] = 2] = "IDEMPOTENT";
210
- MethodOptions_IdempotencyLevel[MethodOptions_IdempotencyLevel["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
211
- })(MethodOptions_IdempotencyLevel || (MethodOptions_IdempotencyLevel = {}));
212
- export var FeatureSet_FieldPresence;
213
- (function (FeatureSet_FieldPresence) {
214
- FeatureSet_FieldPresence[FeatureSet_FieldPresence["FIELD_PRESENCE_UNKNOWN"] = 0] = "FIELD_PRESENCE_UNKNOWN";
215
- FeatureSet_FieldPresence[FeatureSet_FieldPresence["EXPLICIT"] = 1] = "EXPLICIT";
216
- FeatureSet_FieldPresence[FeatureSet_FieldPresence["IMPLICIT"] = 2] = "IMPLICIT";
217
- FeatureSet_FieldPresence[FeatureSet_FieldPresence["LEGACY_REQUIRED"] = 3] = "LEGACY_REQUIRED";
218
- FeatureSet_FieldPresence[FeatureSet_FieldPresence["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
219
- })(FeatureSet_FieldPresence || (FeatureSet_FieldPresence = {}));
220
- export var FeatureSet_EnumType;
221
- (function (FeatureSet_EnumType) {
222
- FeatureSet_EnumType[FeatureSet_EnumType["ENUM_TYPE_UNKNOWN"] = 0] = "ENUM_TYPE_UNKNOWN";
223
- FeatureSet_EnumType[FeatureSet_EnumType["OPEN"] = 1] = "OPEN";
224
- FeatureSet_EnumType[FeatureSet_EnumType["CLOSED"] = 2] = "CLOSED";
225
- FeatureSet_EnumType[FeatureSet_EnumType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
226
- })(FeatureSet_EnumType || (FeatureSet_EnumType = {}));
227
- export var FeatureSet_RepeatedFieldEncoding;
228
- (function (FeatureSet_RepeatedFieldEncoding) {
229
- FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["REPEATED_FIELD_ENCODING_UNKNOWN"] = 0] = "REPEATED_FIELD_ENCODING_UNKNOWN";
230
- FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["PACKED"] = 1] = "PACKED";
231
- FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["EXPANDED"] = 2] = "EXPANDED";
232
- FeatureSet_RepeatedFieldEncoding[FeatureSet_RepeatedFieldEncoding["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
233
- })(FeatureSet_RepeatedFieldEncoding || (FeatureSet_RepeatedFieldEncoding = {}));
234
- export var FeatureSet_Utf8Validation;
235
- (function (FeatureSet_Utf8Validation) {
236
- FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN";
237
- FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["VERIFY"] = 2] = "VERIFY";
238
- FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["NONE"] = 3] = "NONE";
239
- FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
240
- })(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {}));
241
- export var FeatureSet_MessageEncoding;
242
- (function (FeatureSet_MessageEncoding) {
243
- FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["MESSAGE_ENCODING_UNKNOWN"] = 0] = "MESSAGE_ENCODING_UNKNOWN";
244
- FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["LENGTH_PREFIXED"] = 1] = "LENGTH_PREFIXED";
245
- FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["DELIMITED"] = 2] = "DELIMITED";
246
- FeatureSet_MessageEncoding[FeatureSet_MessageEncoding["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
247
- })(FeatureSet_MessageEncoding || (FeatureSet_MessageEncoding = {}));
248
- export var FeatureSet_JsonFormat;
249
- (function (FeatureSet_JsonFormat) {
250
- FeatureSet_JsonFormat[FeatureSet_JsonFormat["JSON_FORMAT_UNKNOWN"] = 0] = "JSON_FORMAT_UNKNOWN";
251
- FeatureSet_JsonFormat[FeatureSet_JsonFormat["ALLOW"] = 1] = "ALLOW";
252
- FeatureSet_JsonFormat[FeatureSet_JsonFormat["LEGACY_BEST_EFFORT"] = 2] = "LEGACY_BEST_EFFORT";
253
- FeatureSet_JsonFormat[FeatureSet_JsonFormat["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
254
- })(FeatureSet_JsonFormat || (FeatureSet_JsonFormat = {}));
255
- export var FeatureSet_EnforceNamingStyle;
256
- (function (FeatureSet_EnforceNamingStyle) {
257
- FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["ENFORCE_NAMING_STYLE_UNKNOWN"] = 0] = "ENFORCE_NAMING_STYLE_UNKNOWN";
258
- FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE2024"] = 1] = "STYLE2024";
259
- FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["STYLE_LEGACY"] = 2] = "STYLE_LEGACY";
260
- FeatureSet_EnforceNamingStyle[FeatureSet_EnforceNamingStyle["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
261
- })(FeatureSet_EnforceNamingStyle || (FeatureSet_EnforceNamingStyle = {}));
262
- export var FeatureSet_VisibilityFeature_DefaultSymbolVisibility;
263
- (function (FeatureSet_VisibilityFeature_DefaultSymbolVisibility) {
264
- FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"] = 0] = "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN";
265
- /** EXPORT_ALL - Default pre-EDITION_2024, all UNSET visibility are export. */
266
- FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["EXPORT_ALL"] = 1] = "EXPORT_ALL";
267
- /** EXPORT_TOP_LEVEL - All top-level symbols default to export, nested default to local. */
268
- FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["EXPORT_TOP_LEVEL"] = 2] = "EXPORT_TOP_LEVEL";
269
- /** LOCAL_ALL - All symbols default to local. */
270
- FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["LOCAL_ALL"] = 3] = "LOCAL_ALL";
271
- /**
272
- * STRICT - All symbols local by default. Nested types cannot be exported.
273
- * With special case caveat for message { enum {} reserved 1 to max; }
274
- * This is the recommended setting for new protos.
275
- */
276
- FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["STRICT"] = 4] = "STRICT";
277
- FeatureSet_VisibilityFeature_DefaultSymbolVisibility[FeatureSet_VisibilityFeature_DefaultSymbolVisibility["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
278
- })(FeatureSet_VisibilityFeature_DefaultSymbolVisibility || (FeatureSet_VisibilityFeature_DefaultSymbolVisibility = {}));
279
- /**
280
- * Represents the identified object's effect on the element in the original
281
- * .proto file.
282
- */
283
- export var GeneratedCodeInfo_Annotation_Semantic;
284
- (function (GeneratedCodeInfo_Annotation_Semantic) {
285
- /** NONE - There is no effect or the effect is indescribable. */
286
- GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["NONE"] = 0] = "NONE";
287
- /** SET - The element is set or otherwise mutated. */
288
- GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["SET"] = 1] = "SET";
289
- /** ALIAS - An alias to the element is returned. */
290
- GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["ALIAS"] = 2] = "ALIAS";
291
- GeneratedCodeInfo_Annotation_Semantic[GeneratedCodeInfo_Annotation_Semantic["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
292
- })(GeneratedCodeInfo_Annotation_Semantic || (GeneratedCodeInfo_Annotation_Semantic = {}));
293
- function createBaseFileDescriptorSet() {
294
- return { file: [] };
295
- }
296
- export const FileDescriptorSet = {
297
- encode(message, writer = new BinaryWriter()) {
298
- for (const v of message.file) {
299
- FileDescriptorProto.encode(v, writer.uint32(10).fork()).join();
300
- }
301
- return writer;
302
- },
303
- decode(input, length) {
304
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
305
- const end = length === undefined ? reader.len : reader.pos + length;
306
- const message = createBaseFileDescriptorSet();
307
- while (reader.pos < end) {
308
- const tag = reader.uint32();
309
- switch (tag >>> 3) {
310
- case 1: {
311
- if (tag !== 10) {
312
- break;
313
- }
314
- message.file.push(FileDescriptorProto.decode(reader, reader.uint32()));
315
- continue;
316
- }
317
- }
318
- if ((tag & 7) === 4 || tag === 0) {
319
- break;
320
- }
321
- reader.skip(tag & 7);
322
- }
323
- return message;
324
- },
325
- create(base) {
326
- return FileDescriptorSet.fromPartial(base ?? {});
327
- },
328
- fromPartial(object) {
329
- const message = createBaseFileDescriptorSet();
330
- message.file = object.file?.map((e) => FileDescriptorProto.fromPartial(e)) || [];
331
- return message;
332
- },
333
- };
334
- function createBaseFileDescriptorProto() {
335
- return {
336
- name: "",
337
- package: "",
338
- dependency: [],
339
- publicDependency: [],
340
- weakDependency: [],
341
- optionDependency: [],
342
- messageType: [],
343
- enumType: [],
344
- service: [],
345
- extension: [],
346
- options: undefined,
347
- sourceCodeInfo: undefined,
348
- syntax: "",
349
- edition: 0,
350
- };
351
- }
352
- export const FileDescriptorProto = {
353
- encode(message, writer = new BinaryWriter()) {
354
- if (message.name !== undefined && message.name !== "") {
355
- writer.uint32(10).string(message.name);
356
- }
357
- if (message.package !== undefined && message.package !== "") {
358
- writer.uint32(18).string(message.package);
359
- }
360
- for (const v of message.dependency) {
361
- writer.uint32(26).string(v);
362
- }
363
- for (const v of message.publicDependency) {
364
- writer.uint32(80).int32(v);
365
- }
366
- for (const v of message.weakDependency) {
367
- writer.uint32(88).int32(v);
368
- }
369
- for (const v of message.optionDependency) {
370
- writer.uint32(122).string(v);
371
- }
372
- for (const v of message.messageType) {
373
- DescriptorProto.encode(v, writer.uint32(34).fork()).join();
374
- }
375
- for (const v of message.enumType) {
376
- EnumDescriptorProto.encode(v, writer.uint32(42).fork()).join();
377
- }
378
- for (const v of message.service) {
379
- ServiceDescriptorProto.encode(v, writer.uint32(50).fork()).join();
380
- }
381
- for (const v of message.extension) {
382
- FieldDescriptorProto.encode(v, writer.uint32(58).fork()).join();
383
- }
384
- if (message.options !== undefined) {
385
- FileOptions.encode(message.options, writer.uint32(66).fork()).join();
386
- }
387
- if (message.sourceCodeInfo !== undefined) {
388
- SourceCodeInfo.encode(message.sourceCodeInfo, writer.uint32(74).fork()).join();
389
- }
390
- if (message.syntax !== undefined && message.syntax !== "") {
391
- writer.uint32(98).string(message.syntax);
392
- }
393
- if (message.edition !== undefined && message.edition !== 0) {
394
- writer.uint32(112).int32(message.edition);
395
- }
396
- return writer;
397
- },
398
- decode(input, length) {
399
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
400
- const end = length === undefined ? reader.len : reader.pos + length;
401
- const message = createBaseFileDescriptorProto();
402
- while (reader.pos < end) {
403
- const tag = reader.uint32();
404
- switch (tag >>> 3) {
405
- case 1: {
406
- if (tag !== 10) {
407
- break;
408
- }
409
- message.name = reader.string();
410
- continue;
411
- }
412
- case 2: {
413
- if (tag !== 18) {
414
- break;
415
- }
416
- message.package = reader.string();
417
- continue;
418
- }
419
- case 3: {
420
- if (tag !== 26) {
421
- break;
422
- }
423
- message.dependency.push(reader.string());
424
- continue;
425
- }
426
- case 10: {
427
- if (tag === 80) {
428
- message.publicDependency.push(reader.int32());
429
- continue;
430
- }
431
- if (tag === 82) {
432
- const end2 = reader.uint32() + reader.pos;
433
- while (reader.pos < end2) {
434
- message.publicDependency.push(reader.int32());
435
- }
436
- continue;
437
- }
438
- break;
439
- }
440
- case 11: {
441
- if (tag === 88) {
442
- message.weakDependency.push(reader.int32());
443
- continue;
444
- }
445
- if (tag === 90) {
446
- const end2 = reader.uint32() + reader.pos;
447
- while (reader.pos < end2) {
448
- message.weakDependency.push(reader.int32());
449
- }
450
- continue;
451
- }
452
- break;
453
- }
454
- case 15: {
455
- if (tag !== 122) {
456
- break;
457
- }
458
- message.optionDependency.push(reader.string());
459
- continue;
460
- }
461
- case 4: {
462
- if (tag !== 34) {
463
- break;
464
- }
465
- message.messageType.push(DescriptorProto.decode(reader, reader.uint32()));
466
- continue;
467
- }
468
- case 5: {
469
- if (tag !== 42) {
470
- break;
471
- }
472
- message.enumType.push(EnumDescriptorProto.decode(reader, reader.uint32()));
473
- continue;
474
- }
475
- case 6: {
476
- if (tag !== 50) {
477
- break;
478
- }
479
- message.service.push(ServiceDescriptorProto.decode(reader, reader.uint32()));
480
- continue;
481
- }
482
- case 7: {
483
- if (tag !== 58) {
484
- break;
485
- }
486
- message.extension.push(FieldDescriptorProto.decode(reader, reader.uint32()));
487
- continue;
488
- }
489
- case 8: {
490
- if (tag !== 66) {
491
- break;
492
- }
493
- message.options = FileOptions.decode(reader, reader.uint32());
494
- continue;
495
- }
496
- case 9: {
497
- if (tag !== 74) {
498
- break;
499
- }
500
- message.sourceCodeInfo = SourceCodeInfo.decode(reader, reader.uint32());
501
- continue;
502
- }
503
- case 12: {
504
- if (tag !== 98) {
505
- break;
506
- }
507
- message.syntax = reader.string();
508
- continue;
509
- }
510
- case 14: {
511
- if (tag !== 112) {
512
- break;
513
- }
514
- message.edition = reader.int32();
515
- continue;
516
- }
517
- }
518
- if ((tag & 7) === 4 || tag === 0) {
519
- break;
520
- }
521
- reader.skip(tag & 7);
522
- }
523
- return message;
524
- },
525
- create(base) {
526
- return FileDescriptorProto.fromPartial(base ?? {});
527
- },
528
- fromPartial(object) {
529
- const message = createBaseFileDescriptorProto();
530
- message.name = object.name ?? "";
531
- message.package = object.package ?? "";
532
- message.dependency = object.dependency?.map((e) => e) || [];
533
- message.publicDependency = object.publicDependency?.map((e) => e) || [];
534
- message.weakDependency = object.weakDependency?.map((e) => e) || [];
535
- message.optionDependency = object.optionDependency?.map((e) => e) || [];
536
- message.messageType = object.messageType?.map((e) => DescriptorProto.fromPartial(e)) || [];
537
- message.enumType = object.enumType?.map((e) => EnumDescriptorProto.fromPartial(e)) || [];
538
- message.service = object.service?.map((e) => ServiceDescriptorProto.fromPartial(e)) || [];
539
- message.extension = object.extension?.map((e) => FieldDescriptorProto.fromPartial(e)) || [];
540
- message.options = (object.options !== undefined && object.options !== null)
541
- ? FileOptions.fromPartial(object.options)
542
- : undefined;
543
- message.sourceCodeInfo = (object.sourceCodeInfo !== undefined && object.sourceCodeInfo !== null)
544
- ? SourceCodeInfo.fromPartial(object.sourceCodeInfo)
545
- : undefined;
546
- message.syntax = object.syntax ?? "";
547
- message.edition = object.edition ?? 0;
548
- return message;
549
- },
550
- };
551
- function createBaseDescriptorProto() {
552
- return {
553
- name: "",
554
- field: [],
555
- extension: [],
556
- nestedType: [],
557
- enumType: [],
558
- extensionRange: [],
559
- oneofDecl: [],
560
- options: undefined,
561
- reservedRange: [],
562
- reservedName: [],
563
- visibility: 0,
564
- };
565
- }
566
- export const DescriptorProto = {
567
- encode(message, writer = new BinaryWriter()) {
568
- if (message.name !== undefined && message.name !== "") {
569
- writer.uint32(10).string(message.name);
570
- }
571
- for (const v of message.field) {
572
- FieldDescriptorProto.encode(v, writer.uint32(18).fork()).join();
573
- }
574
- for (const v of message.extension) {
575
- FieldDescriptorProto.encode(v, writer.uint32(50).fork()).join();
576
- }
577
- for (const v of message.nestedType) {
578
- DescriptorProto.encode(v, writer.uint32(26).fork()).join();
579
- }
580
- for (const v of message.enumType) {
581
- EnumDescriptorProto.encode(v, writer.uint32(34).fork()).join();
582
- }
583
- for (const v of message.extensionRange) {
584
- DescriptorProto_ExtensionRange.encode(v, writer.uint32(42).fork()).join();
585
- }
586
- for (const v of message.oneofDecl) {
587
- OneofDescriptorProto.encode(v, writer.uint32(66).fork()).join();
588
- }
589
- if (message.options !== undefined) {
590
- MessageOptions.encode(message.options, writer.uint32(58).fork()).join();
591
- }
592
- for (const v of message.reservedRange) {
593
- DescriptorProto_ReservedRange.encode(v, writer.uint32(74).fork()).join();
594
- }
595
- for (const v of message.reservedName) {
596
- writer.uint32(82).string(v);
597
- }
598
- if (message.visibility !== undefined && message.visibility !== 0) {
599
- writer.uint32(88).int32(message.visibility);
600
- }
601
- return writer;
602
- },
603
- decode(input, length) {
604
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
605
- const end = length === undefined ? reader.len : reader.pos + length;
606
- const message = createBaseDescriptorProto();
607
- while (reader.pos < end) {
608
- const tag = reader.uint32();
609
- switch (tag >>> 3) {
610
- case 1: {
611
- if (tag !== 10) {
612
- break;
613
- }
614
- message.name = reader.string();
615
- continue;
616
- }
617
- case 2: {
618
- if (tag !== 18) {
619
- break;
620
- }
621
- message.field.push(FieldDescriptorProto.decode(reader, reader.uint32()));
622
- continue;
623
- }
624
- case 6: {
625
- if (tag !== 50) {
626
- break;
627
- }
628
- message.extension.push(FieldDescriptorProto.decode(reader, reader.uint32()));
629
- continue;
630
- }
631
- case 3: {
632
- if (tag !== 26) {
633
- break;
634
- }
635
- message.nestedType.push(DescriptorProto.decode(reader, reader.uint32()));
636
- continue;
637
- }
638
- case 4: {
639
- if (tag !== 34) {
640
- break;
641
- }
642
- message.enumType.push(EnumDescriptorProto.decode(reader, reader.uint32()));
643
- continue;
644
- }
645
- case 5: {
646
- if (tag !== 42) {
647
- break;
648
- }
649
- message.extensionRange.push(DescriptorProto_ExtensionRange.decode(reader, reader.uint32()));
650
- continue;
651
- }
652
- case 8: {
653
- if (tag !== 66) {
654
- break;
655
- }
656
- message.oneofDecl.push(OneofDescriptorProto.decode(reader, reader.uint32()));
657
- continue;
658
- }
659
- case 7: {
660
- if (tag !== 58) {
661
- break;
662
- }
663
- message.options = MessageOptions.decode(reader, reader.uint32());
664
- continue;
665
- }
666
- case 9: {
667
- if (tag !== 74) {
668
- break;
669
- }
670
- message.reservedRange.push(DescriptorProto_ReservedRange.decode(reader, reader.uint32()));
671
- continue;
672
- }
673
- case 10: {
674
- if (tag !== 82) {
675
- break;
676
- }
677
- message.reservedName.push(reader.string());
678
- continue;
679
- }
680
- case 11: {
681
- if (tag !== 88) {
682
- break;
683
- }
684
- message.visibility = reader.int32();
685
- continue;
686
- }
687
- }
688
- if ((tag & 7) === 4 || tag === 0) {
689
- break;
690
- }
691
- reader.skip(tag & 7);
692
- }
693
- return message;
694
- },
695
- create(base) {
696
- return DescriptorProto.fromPartial(base ?? {});
697
- },
698
- fromPartial(object) {
699
- const message = createBaseDescriptorProto();
700
- message.name = object.name ?? "";
701
- message.field = object.field?.map((e) => FieldDescriptorProto.fromPartial(e)) || [];
702
- message.extension = object.extension?.map((e) => FieldDescriptorProto.fromPartial(e)) || [];
703
- message.nestedType = object.nestedType?.map((e) => DescriptorProto.fromPartial(e)) || [];
704
- message.enumType = object.enumType?.map((e) => EnumDescriptorProto.fromPartial(e)) || [];
705
- message.extensionRange = object.extensionRange?.map((e) => DescriptorProto_ExtensionRange.fromPartial(e)) || [];
706
- message.oneofDecl = object.oneofDecl?.map((e) => OneofDescriptorProto.fromPartial(e)) || [];
707
- message.options = (object.options !== undefined && object.options !== null)
708
- ? MessageOptions.fromPartial(object.options)
709
- : undefined;
710
- message.reservedRange = object.reservedRange?.map((e) => DescriptorProto_ReservedRange.fromPartial(e)) || [];
711
- message.reservedName = object.reservedName?.map((e) => e) || [];
712
- message.visibility = object.visibility ?? 0;
713
- return message;
714
- },
715
- };
716
- function createBaseDescriptorProto_ExtensionRange() {
717
- return { start: 0, end: 0, options: undefined };
718
- }
719
- export const DescriptorProto_ExtensionRange = {
720
- encode(message, writer = new BinaryWriter()) {
721
- if (message.start !== undefined && message.start !== 0) {
722
- writer.uint32(8).int32(message.start);
723
- }
724
- if (message.end !== undefined && message.end !== 0) {
725
- writer.uint32(16).int32(message.end);
726
- }
727
- if (message.options !== undefined) {
728
- ExtensionRangeOptions.encode(message.options, writer.uint32(26).fork()).join();
729
- }
730
- return writer;
731
- },
732
- decode(input, length) {
733
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
734
- const end = length === undefined ? reader.len : reader.pos + length;
735
- const message = createBaseDescriptorProto_ExtensionRange();
736
- while (reader.pos < end) {
737
- const tag = reader.uint32();
738
- switch (tag >>> 3) {
739
- case 1: {
740
- if (tag !== 8) {
741
- break;
742
- }
743
- message.start = reader.int32();
744
- continue;
745
- }
746
- case 2: {
747
- if (tag !== 16) {
748
- break;
749
- }
750
- message.end = reader.int32();
751
- continue;
752
- }
753
- case 3: {
754
- if (tag !== 26) {
755
- break;
756
- }
757
- message.options = ExtensionRangeOptions.decode(reader, reader.uint32());
758
- continue;
759
- }
760
- }
761
- if ((tag & 7) === 4 || tag === 0) {
762
- break;
763
- }
764
- reader.skip(tag & 7);
765
- }
766
- return message;
767
- },
768
- create(base) {
769
- return DescriptorProto_ExtensionRange.fromPartial(base ?? {});
770
- },
771
- fromPartial(object) {
772
- const message = createBaseDescriptorProto_ExtensionRange();
773
- message.start = object.start ?? 0;
774
- message.end = object.end ?? 0;
775
- message.options = (object.options !== undefined && object.options !== null)
776
- ? ExtensionRangeOptions.fromPartial(object.options)
777
- : undefined;
778
- return message;
779
- },
780
- };
781
- function createBaseDescriptorProto_ReservedRange() {
782
- return { start: 0, end: 0 };
783
- }
784
- export const DescriptorProto_ReservedRange = {
785
- encode(message, writer = new BinaryWriter()) {
786
- if (message.start !== undefined && message.start !== 0) {
787
- writer.uint32(8).int32(message.start);
788
- }
789
- if (message.end !== undefined && message.end !== 0) {
790
- writer.uint32(16).int32(message.end);
791
- }
792
- return writer;
793
- },
794
- decode(input, length) {
795
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
796
- const end = length === undefined ? reader.len : reader.pos + length;
797
- const message = createBaseDescriptorProto_ReservedRange();
798
- while (reader.pos < end) {
799
- const tag = reader.uint32();
800
- switch (tag >>> 3) {
801
- case 1: {
802
- if (tag !== 8) {
803
- break;
804
- }
805
- message.start = reader.int32();
806
- continue;
807
- }
808
- case 2: {
809
- if (tag !== 16) {
810
- break;
811
- }
812
- message.end = reader.int32();
813
- continue;
814
- }
815
- }
816
- if ((tag & 7) === 4 || tag === 0) {
817
- break;
818
- }
819
- reader.skip(tag & 7);
820
- }
821
- return message;
822
- },
823
- create(base) {
824
- return DescriptorProto_ReservedRange.fromPartial(base ?? {});
825
- },
826
- fromPartial(object) {
827
- const message = createBaseDescriptorProto_ReservedRange();
828
- message.start = object.start ?? 0;
829
- message.end = object.end ?? 0;
830
- return message;
831
- },
832
- };
833
- function createBaseExtensionRangeOptions() {
834
- return { uninterpretedOption: [], declaration: [], features: undefined, verification: 1 };
835
- }
836
- export const ExtensionRangeOptions = {
837
- encode(message, writer = new BinaryWriter()) {
838
- for (const v of message.uninterpretedOption) {
839
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
840
- }
841
- for (const v of message.declaration) {
842
- ExtensionRangeOptions_Declaration.encode(v, writer.uint32(18).fork()).join();
843
- }
844
- if (message.features !== undefined) {
845
- FeatureSet.encode(message.features, writer.uint32(402).fork()).join();
846
- }
847
- if (message.verification !== undefined && message.verification !== 1) {
848
- writer.uint32(24).int32(message.verification);
849
- }
850
- return writer;
851
- },
852
- decode(input, length) {
853
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
854
- const end = length === undefined ? reader.len : reader.pos + length;
855
- const message = createBaseExtensionRangeOptions();
856
- while (reader.pos < end) {
857
- const tag = reader.uint32();
858
- switch (tag >>> 3) {
859
- case 999: {
860
- if (tag !== 7994) {
861
- break;
862
- }
863
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
864
- continue;
865
- }
866
- case 2: {
867
- if (tag !== 18) {
868
- break;
869
- }
870
- message.declaration.push(ExtensionRangeOptions_Declaration.decode(reader, reader.uint32()));
871
- continue;
872
- }
873
- case 50: {
874
- if (tag !== 402) {
875
- break;
876
- }
877
- message.features = FeatureSet.decode(reader, reader.uint32());
878
- continue;
879
- }
880
- case 3: {
881
- if (tag !== 24) {
882
- break;
883
- }
884
- message.verification = reader.int32();
885
- continue;
886
- }
887
- }
888
- if ((tag & 7) === 4 || tag === 0) {
889
- break;
890
- }
891
- reader.skip(tag & 7);
892
- }
893
- return message;
894
- },
895
- create(base) {
896
- return ExtensionRangeOptions.fromPartial(base ?? {});
897
- },
898
- fromPartial(object) {
899
- const message = createBaseExtensionRangeOptions();
900
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
901
- message.declaration = object.declaration?.map((e) => ExtensionRangeOptions_Declaration.fromPartial(e)) || [];
902
- message.features = (object.features !== undefined && object.features !== null)
903
- ? FeatureSet.fromPartial(object.features)
904
- : undefined;
905
- message.verification = object.verification ?? 1;
906
- return message;
907
- },
908
- };
909
- function createBaseExtensionRangeOptions_Declaration() {
910
- return { number: 0, fullName: "", type: "", reserved: false, repeated: false };
911
- }
912
- export const ExtensionRangeOptions_Declaration = {
913
- encode(message, writer = new BinaryWriter()) {
914
- if (message.number !== undefined && message.number !== 0) {
915
- writer.uint32(8).int32(message.number);
916
- }
917
- if (message.fullName !== undefined && message.fullName !== "") {
918
- writer.uint32(18).string(message.fullName);
919
- }
920
- if (message.type !== undefined && message.type !== "") {
921
- writer.uint32(26).string(message.type);
922
- }
923
- if (message.reserved !== undefined && message.reserved !== false) {
924
- writer.uint32(40).bool(message.reserved);
925
- }
926
- if (message.repeated !== undefined && message.repeated !== false) {
927
- writer.uint32(48).bool(message.repeated);
928
- }
929
- return writer;
930
- },
931
- decode(input, length) {
932
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
933
- const end = length === undefined ? reader.len : reader.pos + length;
934
- const message = createBaseExtensionRangeOptions_Declaration();
935
- while (reader.pos < end) {
936
- const tag = reader.uint32();
937
- switch (tag >>> 3) {
938
- case 1: {
939
- if (tag !== 8) {
940
- break;
941
- }
942
- message.number = reader.int32();
943
- continue;
944
- }
945
- case 2: {
946
- if (tag !== 18) {
947
- break;
948
- }
949
- message.fullName = reader.string();
950
- continue;
951
- }
952
- case 3: {
953
- if (tag !== 26) {
954
- break;
955
- }
956
- message.type = reader.string();
957
- continue;
958
- }
959
- case 5: {
960
- if (tag !== 40) {
961
- break;
962
- }
963
- message.reserved = reader.bool();
964
- continue;
965
- }
966
- case 6: {
967
- if (tag !== 48) {
968
- break;
969
- }
970
- message.repeated = reader.bool();
971
- continue;
972
- }
973
- }
974
- if ((tag & 7) === 4 || tag === 0) {
975
- break;
976
- }
977
- reader.skip(tag & 7);
978
- }
979
- return message;
980
- },
981
- create(base) {
982
- return ExtensionRangeOptions_Declaration.fromPartial(base ?? {});
983
- },
984
- fromPartial(object) {
985
- const message = createBaseExtensionRangeOptions_Declaration();
986
- message.number = object.number ?? 0;
987
- message.fullName = object.fullName ?? "";
988
- message.type = object.type ?? "";
989
- message.reserved = object.reserved ?? false;
990
- message.repeated = object.repeated ?? false;
991
- return message;
992
- },
993
- };
994
- function createBaseFieldDescriptorProto() {
995
- return {
996
- name: "",
997
- number: 0,
998
- label: 1,
999
- type: 1,
1000
- typeName: "",
1001
- extendee: "",
1002
- defaultValue: "",
1003
- oneofIndex: 0,
1004
- jsonName: "",
1005
- options: undefined,
1006
- proto3Optional: false,
1007
- };
1008
- }
1009
- export const FieldDescriptorProto = {
1010
- encode(message, writer = new BinaryWriter()) {
1011
- if (message.name !== undefined && message.name !== "") {
1012
- writer.uint32(10).string(message.name);
1013
- }
1014
- if (message.number !== undefined && message.number !== 0) {
1015
- writer.uint32(24).int32(message.number);
1016
- }
1017
- if (message.label !== undefined && message.label !== 1) {
1018
- writer.uint32(32).int32(message.label);
1019
- }
1020
- if (message.type !== undefined && message.type !== 1) {
1021
- writer.uint32(40).int32(message.type);
1022
- }
1023
- if (message.typeName !== undefined && message.typeName !== "") {
1024
- writer.uint32(50).string(message.typeName);
1025
- }
1026
- if (message.extendee !== undefined && message.extendee !== "") {
1027
- writer.uint32(18).string(message.extendee);
1028
- }
1029
- if (message.defaultValue !== undefined && message.defaultValue !== "") {
1030
- writer.uint32(58).string(message.defaultValue);
1031
- }
1032
- if (message.oneofIndex !== undefined && message.oneofIndex !== 0) {
1033
- writer.uint32(72).int32(message.oneofIndex);
1034
- }
1035
- if (message.jsonName !== undefined && message.jsonName !== "") {
1036
- writer.uint32(82).string(message.jsonName);
1037
- }
1038
- if (message.options !== undefined) {
1039
- FieldOptions.encode(message.options, writer.uint32(66).fork()).join();
1040
- }
1041
- if (message.proto3Optional !== undefined && message.proto3Optional !== false) {
1042
- writer.uint32(136).bool(message.proto3Optional);
1043
- }
1044
- return writer;
1045
- },
1046
- decode(input, length) {
1047
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1048
- const end = length === undefined ? reader.len : reader.pos + length;
1049
- const message = createBaseFieldDescriptorProto();
1050
- while (reader.pos < end) {
1051
- const tag = reader.uint32();
1052
- switch (tag >>> 3) {
1053
- case 1: {
1054
- if (tag !== 10) {
1055
- break;
1056
- }
1057
- message.name = reader.string();
1058
- continue;
1059
- }
1060
- case 3: {
1061
- if (tag !== 24) {
1062
- break;
1063
- }
1064
- message.number = reader.int32();
1065
- continue;
1066
- }
1067
- case 4: {
1068
- if (tag !== 32) {
1069
- break;
1070
- }
1071
- message.label = reader.int32();
1072
- continue;
1073
- }
1074
- case 5: {
1075
- if (tag !== 40) {
1076
- break;
1077
- }
1078
- message.type = reader.int32();
1079
- continue;
1080
- }
1081
- case 6: {
1082
- if (tag !== 50) {
1083
- break;
1084
- }
1085
- message.typeName = reader.string();
1086
- continue;
1087
- }
1088
- case 2: {
1089
- if (tag !== 18) {
1090
- break;
1091
- }
1092
- message.extendee = reader.string();
1093
- continue;
1094
- }
1095
- case 7: {
1096
- if (tag !== 58) {
1097
- break;
1098
- }
1099
- message.defaultValue = reader.string();
1100
- continue;
1101
- }
1102
- case 9: {
1103
- if (tag !== 72) {
1104
- break;
1105
- }
1106
- message.oneofIndex = reader.int32();
1107
- continue;
1108
- }
1109
- case 10: {
1110
- if (tag !== 82) {
1111
- break;
1112
- }
1113
- message.jsonName = reader.string();
1114
- continue;
1115
- }
1116
- case 8: {
1117
- if (tag !== 66) {
1118
- break;
1119
- }
1120
- message.options = FieldOptions.decode(reader, reader.uint32());
1121
- continue;
1122
- }
1123
- case 17: {
1124
- if (tag !== 136) {
1125
- break;
1126
- }
1127
- message.proto3Optional = reader.bool();
1128
- continue;
1129
- }
1130
- }
1131
- if ((tag & 7) === 4 || tag === 0) {
1132
- break;
1133
- }
1134
- reader.skip(tag & 7);
1135
- }
1136
- return message;
1137
- },
1138
- create(base) {
1139
- return FieldDescriptorProto.fromPartial(base ?? {});
1140
- },
1141
- fromPartial(object) {
1142
- const message = createBaseFieldDescriptorProto();
1143
- message.name = object.name ?? "";
1144
- message.number = object.number ?? 0;
1145
- message.label = object.label ?? 1;
1146
- message.type = object.type ?? 1;
1147
- message.typeName = object.typeName ?? "";
1148
- message.extendee = object.extendee ?? "";
1149
- message.defaultValue = object.defaultValue ?? "";
1150
- message.oneofIndex = object.oneofIndex ?? 0;
1151
- message.jsonName = object.jsonName ?? "";
1152
- message.options = (object.options !== undefined && object.options !== null)
1153
- ? FieldOptions.fromPartial(object.options)
1154
- : undefined;
1155
- message.proto3Optional = object.proto3Optional ?? false;
1156
- return message;
1157
- },
1158
- };
1159
- function createBaseOneofDescriptorProto() {
1160
- return { name: "", options: undefined };
1161
- }
1162
- export const OneofDescriptorProto = {
1163
- encode(message, writer = new BinaryWriter()) {
1164
- if (message.name !== undefined && message.name !== "") {
1165
- writer.uint32(10).string(message.name);
1166
- }
1167
- if (message.options !== undefined) {
1168
- OneofOptions.encode(message.options, writer.uint32(18).fork()).join();
1169
- }
1170
- return writer;
1171
- },
1172
- decode(input, length) {
1173
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1174
- const end = length === undefined ? reader.len : reader.pos + length;
1175
- const message = createBaseOneofDescriptorProto();
1176
- while (reader.pos < end) {
1177
- const tag = reader.uint32();
1178
- switch (tag >>> 3) {
1179
- case 1: {
1180
- if (tag !== 10) {
1181
- break;
1182
- }
1183
- message.name = reader.string();
1184
- continue;
1185
- }
1186
- case 2: {
1187
- if (tag !== 18) {
1188
- break;
1189
- }
1190
- message.options = OneofOptions.decode(reader, reader.uint32());
1191
- continue;
1192
- }
1193
- }
1194
- if ((tag & 7) === 4 || tag === 0) {
1195
- break;
1196
- }
1197
- reader.skip(tag & 7);
1198
- }
1199
- return message;
1200
- },
1201
- create(base) {
1202
- return OneofDescriptorProto.fromPartial(base ?? {});
1203
- },
1204
- fromPartial(object) {
1205
- const message = createBaseOneofDescriptorProto();
1206
- message.name = object.name ?? "";
1207
- message.options = (object.options !== undefined && object.options !== null)
1208
- ? OneofOptions.fromPartial(object.options)
1209
- : undefined;
1210
- return message;
1211
- },
1212
- };
1213
- function createBaseEnumDescriptorProto() {
1214
- return { name: "", value: [], options: undefined, reservedRange: [], reservedName: [], visibility: 0 };
1215
- }
1216
- export const EnumDescriptorProto = {
1217
- encode(message, writer = new BinaryWriter()) {
1218
- if (message.name !== undefined && message.name !== "") {
1219
- writer.uint32(10).string(message.name);
1220
- }
1221
- for (const v of message.value) {
1222
- EnumValueDescriptorProto.encode(v, writer.uint32(18).fork()).join();
1223
- }
1224
- if (message.options !== undefined) {
1225
- EnumOptions.encode(message.options, writer.uint32(26).fork()).join();
1226
- }
1227
- for (const v of message.reservedRange) {
1228
- EnumDescriptorProto_EnumReservedRange.encode(v, writer.uint32(34).fork()).join();
1229
- }
1230
- for (const v of message.reservedName) {
1231
- writer.uint32(42).string(v);
1232
- }
1233
- if (message.visibility !== undefined && message.visibility !== 0) {
1234
- writer.uint32(48).int32(message.visibility);
1235
- }
1236
- return writer;
1237
- },
1238
- decode(input, length) {
1239
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1240
- const end = length === undefined ? reader.len : reader.pos + length;
1241
- const message = createBaseEnumDescriptorProto();
1242
- while (reader.pos < end) {
1243
- const tag = reader.uint32();
1244
- switch (tag >>> 3) {
1245
- case 1: {
1246
- if (tag !== 10) {
1247
- break;
1248
- }
1249
- message.name = reader.string();
1250
- continue;
1251
- }
1252
- case 2: {
1253
- if (tag !== 18) {
1254
- break;
1255
- }
1256
- message.value.push(EnumValueDescriptorProto.decode(reader, reader.uint32()));
1257
- continue;
1258
- }
1259
- case 3: {
1260
- if (tag !== 26) {
1261
- break;
1262
- }
1263
- message.options = EnumOptions.decode(reader, reader.uint32());
1264
- continue;
1265
- }
1266
- case 4: {
1267
- if (tag !== 34) {
1268
- break;
1269
- }
1270
- message.reservedRange.push(EnumDescriptorProto_EnumReservedRange.decode(reader, reader.uint32()));
1271
- continue;
1272
- }
1273
- case 5: {
1274
- if (tag !== 42) {
1275
- break;
1276
- }
1277
- message.reservedName.push(reader.string());
1278
- continue;
1279
- }
1280
- case 6: {
1281
- if (tag !== 48) {
1282
- break;
1283
- }
1284
- message.visibility = reader.int32();
1285
- continue;
1286
- }
1287
- }
1288
- if ((tag & 7) === 4 || tag === 0) {
1289
- break;
1290
- }
1291
- reader.skip(tag & 7);
1292
- }
1293
- return message;
1294
- },
1295
- create(base) {
1296
- return EnumDescriptorProto.fromPartial(base ?? {});
1297
- },
1298
- fromPartial(object) {
1299
- const message = createBaseEnumDescriptorProto();
1300
- message.name = object.name ?? "";
1301
- message.value = object.value?.map((e) => EnumValueDescriptorProto.fromPartial(e)) || [];
1302
- message.options = (object.options !== undefined && object.options !== null)
1303
- ? EnumOptions.fromPartial(object.options)
1304
- : undefined;
1305
- message.reservedRange = object.reservedRange?.map((e) => EnumDescriptorProto_EnumReservedRange.fromPartial(e)) ||
1306
- [];
1307
- message.reservedName = object.reservedName?.map((e) => e) || [];
1308
- message.visibility = object.visibility ?? 0;
1309
- return message;
1310
- },
1311
- };
1312
- function createBaseEnumDescriptorProto_EnumReservedRange() {
1313
- return { start: 0, end: 0 };
1314
- }
1315
- export const EnumDescriptorProto_EnumReservedRange = {
1316
- encode(message, writer = new BinaryWriter()) {
1317
- if (message.start !== undefined && message.start !== 0) {
1318
- writer.uint32(8).int32(message.start);
1319
- }
1320
- if (message.end !== undefined && message.end !== 0) {
1321
- writer.uint32(16).int32(message.end);
1322
- }
1323
- return writer;
1324
- },
1325
- decode(input, length) {
1326
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1327
- const end = length === undefined ? reader.len : reader.pos + length;
1328
- const message = createBaseEnumDescriptorProto_EnumReservedRange();
1329
- while (reader.pos < end) {
1330
- const tag = reader.uint32();
1331
- switch (tag >>> 3) {
1332
- case 1: {
1333
- if (tag !== 8) {
1334
- break;
1335
- }
1336
- message.start = reader.int32();
1337
- continue;
1338
- }
1339
- case 2: {
1340
- if (tag !== 16) {
1341
- break;
1342
- }
1343
- message.end = reader.int32();
1344
- continue;
1345
- }
1346
- }
1347
- if ((tag & 7) === 4 || tag === 0) {
1348
- break;
1349
- }
1350
- reader.skip(tag & 7);
1351
- }
1352
- return message;
1353
- },
1354
- create(base) {
1355
- return EnumDescriptorProto_EnumReservedRange.fromPartial(base ?? {});
1356
- },
1357
- fromPartial(object) {
1358
- const message = createBaseEnumDescriptorProto_EnumReservedRange();
1359
- message.start = object.start ?? 0;
1360
- message.end = object.end ?? 0;
1361
- return message;
1362
- },
1363
- };
1364
- function createBaseEnumValueDescriptorProto() {
1365
- return { name: "", number: 0, options: undefined };
1366
- }
1367
- export const EnumValueDescriptorProto = {
1368
- encode(message, writer = new BinaryWriter()) {
1369
- if (message.name !== undefined && message.name !== "") {
1370
- writer.uint32(10).string(message.name);
1371
- }
1372
- if (message.number !== undefined && message.number !== 0) {
1373
- writer.uint32(16).int32(message.number);
1374
- }
1375
- if (message.options !== undefined) {
1376
- EnumValueOptions.encode(message.options, writer.uint32(26).fork()).join();
1377
- }
1378
- return writer;
1379
- },
1380
- decode(input, length) {
1381
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1382
- const end = length === undefined ? reader.len : reader.pos + length;
1383
- const message = createBaseEnumValueDescriptorProto();
1384
- while (reader.pos < end) {
1385
- const tag = reader.uint32();
1386
- switch (tag >>> 3) {
1387
- case 1: {
1388
- if (tag !== 10) {
1389
- break;
1390
- }
1391
- message.name = reader.string();
1392
- continue;
1393
- }
1394
- case 2: {
1395
- if (tag !== 16) {
1396
- break;
1397
- }
1398
- message.number = reader.int32();
1399
- continue;
1400
- }
1401
- case 3: {
1402
- if (tag !== 26) {
1403
- break;
1404
- }
1405
- message.options = EnumValueOptions.decode(reader, reader.uint32());
1406
- continue;
1407
- }
1408
- }
1409
- if ((tag & 7) === 4 || tag === 0) {
1410
- break;
1411
- }
1412
- reader.skip(tag & 7);
1413
- }
1414
- return message;
1415
- },
1416
- create(base) {
1417
- return EnumValueDescriptorProto.fromPartial(base ?? {});
1418
- },
1419
- fromPartial(object) {
1420
- const message = createBaseEnumValueDescriptorProto();
1421
- message.name = object.name ?? "";
1422
- message.number = object.number ?? 0;
1423
- message.options = (object.options !== undefined && object.options !== null)
1424
- ? EnumValueOptions.fromPartial(object.options)
1425
- : undefined;
1426
- return message;
1427
- },
1428
- };
1429
- function createBaseServiceDescriptorProto() {
1430
- return { name: "", method: [], options: undefined };
1431
- }
1432
- export const ServiceDescriptorProto = {
1433
- encode(message, writer = new BinaryWriter()) {
1434
- if (message.name !== undefined && message.name !== "") {
1435
- writer.uint32(10).string(message.name);
1436
- }
1437
- for (const v of message.method) {
1438
- MethodDescriptorProto.encode(v, writer.uint32(18).fork()).join();
1439
- }
1440
- if (message.options !== undefined) {
1441
- ServiceOptions.encode(message.options, writer.uint32(26).fork()).join();
1442
- }
1443
- return writer;
1444
- },
1445
- decode(input, length) {
1446
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1447
- const end = length === undefined ? reader.len : reader.pos + length;
1448
- const message = createBaseServiceDescriptorProto();
1449
- while (reader.pos < end) {
1450
- const tag = reader.uint32();
1451
- switch (tag >>> 3) {
1452
- case 1: {
1453
- if (tag !== 10) {
1454
- break;
1455
- }
1456
- message.name = reader.string();
1457
- continue;
1458
- }
1459
- case 2: {
1460
- if (tag !== 18) {
1461
- break;
1462
- }
1463
- message.method.push(MethodDescriptorProto.decode(reader, reader.uint32()));
1464
- continue;
1465
- }
1466
- case 3: {
1467
- if (tag !== 26) {
1468
- break;
1469
- }
1470
- message.options = ServiceOptions.decode(reader, reader.uint32());
1471
- continue;
1472
- }
1473
- }
1474
- if ((tag & 7) === 4 || tag === 0) {
1475
- break;
1476
- }
1477
- reader.skip(tag & 7);
1478
- }
1479
- return message;
1480
- },
1481
- create(base) {
1482
- return ServiceDescriptorProto.fromPartial(base ?? {});
1483
- },
1484
- fromPartial(object) {
1485
- const message = createBaseServiceDescriptorProto();
1486
- message.name = object.name ?? "";
1487
- message.method = object.method?.map((e) => MethodDescriptorProto.fromPartial(e)) || [];
1488
- message.options = (object.options !== undefined && object.options !== null)
1489
- ? ServiceOptions.fromPartial(object.options)
1490
- : undefined;
1491
- return message;
1492
- },
1493
- };
1494
- function createBaseMethodDescriptorProto() {
1495
- return {
1496
- name: "",
1497
- inputType: "",
1498
- outputType: "",
1499
- options: undefined,
1500
- clientStreaming: false,
1501
- serverStreaming: false,
1502
- };
1503
- }
1504
- export const MethodDescriptorProto = {
1505
- encode(message, writer = new BinaryWriter()) {
1506
- if (message.name !== undefined && message.name !== "") {
1507
- writer.uint32(10).string(message.name);
1508
- }
1509
- if (message.inputType !== undefined && message.inputType !== "") {
1510
- writer.uint32(18).string(message.inputType);
1511
- }
1512
- if (message.outputType !== undefined && message.outputType !== "") {
1513
- writer.uint32(26).string(message.outputType);
1514
- }
1515
- if (message.options !== undefined) {
1516
- MethodOptions.encode(message.options, writer.uint32(34).fork()).join();
1517
- }
1518
- if (message.clientStreaming !== undefined && message.clientStreaming !== false) {
1519
- writer.uint32(40).bool(message.clientStreaming);
1520
- }
1521
- if (message.serverStreaming !== undefined && message.serverStreaming !== false) {
1522
- writer.uint32(48).bool(message.serverStreaming);
1523
- }
1524
- return writer;
1525
- },
1526
- decode(input, length) {
1527
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1528
- const end = length === undefined ? reader.len : reader.pos + length;
1529
- const message = createBaseMethodDescriptorProto();
1530
- while (reader.pos < end) {
1531
- const tag = reader.uint32();
1532
- switch (tag >>> 3) {
1533
- case 1: {
1534
- if (tag !== 10) {
1535
- break;
1536
- }
1537
- message.name = reader.string();
1538
- continue;
1539
- }
1540
- case 2: {
1541
- if (tag !== 18) {
1542
- break;
1543
- }
1544
- message.inputType = reader.string();
1545
- continue;
1546
- }
1547
- case 3: {
1548
- if (tag !== 26) {
1549
- break;
1550
- }
1551
- message.outputType = reader.string();
1552
- continue;
1553
- }
1554
- case 4: {
1555
- if (tag !== 34) {
1556
- break;
1557
- }
1558
- message.options = MethodOptions.decode(reader, reader.uint32());
1559
- continue;
1560
- }
1561
- case 5: {
1562
- if (tag !== 40) {
1563
- break;
1564
- }
1565
- message.clientStreaming = reader.bool();
1566
- continue;
1567
- }
1568
- case 6: {
1569
- if (tag !== 48) {
1570
- break;
1571
- }
1572
- message.serverStreaming = reader.bool();
1573
- continue;
1574
- }
1575
- }
1576
- if ((tag & 7) === 4 || tag === 0) {
1577
- break;
1578
- }
1579
- reader.skip(tag & 7);
1580
- }
1581
- return message;
1582
- },
1583
- create(base) {
1584
- return MethodDescriptorProto.fromPartial(base ?? {});
1585
- },
1586
- fromPartial(object) {
1587
- const message = createBaseMethodDescriptorProto();
1588
- message.name = object.name ?? "";
1589
- message.inputType = object.inputType ?? "";
1590
- message.outputType = object.outputType ?? "";
1591
- message.options = (object.options !== undefined && object.options !== null)
1592
- ? MethodOptions.fromPartial(object.options)
1593
- : undefined;
1594
- message.clientStreaming = object.clientStreaming ?? false;
1595
- message.serverStreaming = object.serverStreaming ?? false;
1596
- return message;
1597
- },
1598
- };
1599
- function createBaseFileOptions() {
1600
- return {
1601
- javaPackage: "",
1602
- javaOuterClassname: "",
1603
- javaMultipleFiles: false,
1604
- javaGenerateEqualsAndHash: false,
1605
- javaStringCheckUtf8: false,
1606
- optimizeFor: 1,
1607
- goPackage: "",
1608
- ccGenericServices: false,
1609
- javaGenericServices: false,
1610
- pyGenericServices: false,
1611
- deprecated: false,
1612
- ccEnableArenas: true,
1613
- objcClassPrefix: "",
1614
- csharpNamespace: "",
1615
- swiftPrefix: "",
1616
- phpClassPrefix: "",
1617
- phpNamespace: "",
1618
- phpMetadataNamespace: "",
1619
- rubyPackage: "",
1620
- features: undefined,
1621
- uninterpretedOption: [],
1622
- };
1623
- }
1624
- export const FileOptions = {
1625
- encode(message, writer = new BinaryWriter()) {
1626
- if (message.javaPackage !== undefined && message.javaPackage !== "") {
1627
- writer.uint32(10).string(message.javaPackage);
1628
- }
1629
- if (message.javaOuterClassname !== undefined && message.javaOuterClassname !== "") {
1630
- writer.uint32(66).string(message.javaOuterClassname);
1631
- }
1632
- if (message.javaMultipleFiles !== undefined && message.javaMultipleFiles !== false) {
1633
- writer.uint32(80).bool(message.javaMultipleFiles);
1634
- }
1635
- if (message.javaGenerateEqualsAndHash !== undefined && message.javaGenerateEqualsAndHash !== false) {
1636
- writer.uint32(160).bool(message.javaGenerateEqualsAndHash);
1637
- }
1638
- if (message.javaStringCheckUtf8 !== undefined && message.javaStringCheckUtf8 !== false) {
1639
- writer.uint32(216).bool(message.javaStringCheckUtf8);
1640
- }
1641
- if (message.optimizeFor !== undefined && message.optimizeFor !== 1) {
1642
- writer.uint32(72).int32(message.optimizeFor);
1643
- }
1644
- if (message.goPackage !== undefined && message.goPackage !== "") {
1645
- writer.uint32(90).string(message.goPackage);
1646
- }
1647
- if (message.ccGenericServices !== undefined && message.ccGenericServices !== false) {
1648
- writer.uint32(128).bool(message.ccGenericServices);
1649
- }
1650
- if (message.javaGenericServices !== undefined && message.javaGenericServices !== false) {
1651
- writer.uint32(136).bool(message.javaGenericServices);
1652
- }
1653
- if (message.pyGenericServices !== undefined && message.pyGenericServices !== false) {
1654
- writer.uint32(144).bool(message.pyGenericServices);
1655
- }
1656
- if (message.deprecated !== undefined && message.deprecated !== false) {
1657
- writer.uint32(184).bool(message.deprecated);
1658
- }
1659
- if (message.ccEnableArenas !== undefined && message.ccEnableArenas !== true) {
1660
- writer.uint32(248).bool(message.ccEnableArenas);
1661
- }
1662
- if (message.objcClassPrefix !== undefined && message.objcClassPrefix !== "") {
1663
- writer.uint32(290).string(message.objcClassPrefix);
1664
- }
1665
- if (message.csharpNamespace !== undefined && message.csharpNamespace !== "") {
1666
- writer.uint32(298).string(message.csharpNamespace);
1667
- }
1668
- if (message.swiftPrefix !== undefined && message.swiftPrefix !== "") {
1669
- writer.uint32(314).string(message.swiftPrefix);
1670
- }
1671
- if (message.phpClassPrefix !== undefined && message.phpClassPrefix !== "") {
1672
- writer.uint32(322).string(message.phpClassPrefix);
1673
- }
1674
- if (message.phpNamespace !== undefined && message.phpNamespace !== "") {
1675
- writer.uint32(330).string(message.phpNamespace);
1676
- }
1677
- if (message.phpMetadataNamespace !== undefined && message.phpMetadataNamespace !== "") {
1678
- writer.uint32(354).string(message.phpMetadataNamespace);
1679
- }
1680
- if (message.rubyPackage !== undefined && message.rubyPackage !== "") {
1681
- writer.uint32(362).string(message.rubyPackage);
1682
- }
1683
- if (message.features !== undefined) {
1684
- FeatureSet.encode(message.features, writer.uint32(402).fork()).join();
1685
- }
1686
- for (const v of message.uninterpretedOption) {
1687
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
1688
- }
1689
- return writer;
1690
- },
1691
- decode(input, length) {
1692
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1693
- const end = length === undefined ? reader.len : reader.pos + length;
1694
- const message = createBaseFileOptions();
1695
- while (reader.pos < end) {
1696
- const tag = reader.uint32();
1697
- switch (tag >>> 3) {
1698
- case 1: {
1699
- if (tag !== 10) {
1700
- break;
1701
- }
1702
- message.javaPackage = reader.string();
1703
- continue;
1704
- }
1705
- case 8: {
1706
- if (tag !== 66) {
1707
- break;
1708
- }
1709
- message.javaOuterClassname = reader.string();
1710
- continue;
1711
- }
1712
- case 10: {
1713
- if (tag !== 80) {
1714
- break;
1715
- }
1716
- message.javaMultipleFiles = reader.bool();
1717
- continue;
1718
- }
1719
- case 20: {
1720
- if (tag !== 160) {
1721
- break;
1722
- }
1723
- message.javaGenerateEqualsAndHash = reader.bool();
1724
- continue;
1725
- }
1726
- case 27: {
1727
- if (tag !== 216) {
1728
- break;
1729
- }
1730
- message.javaStringCheckUtf8 = reader.bool();
1731
- continue;
1732
- }
1733
- case 9: {
1734
- if (tag !== 72) {
1735
- break;
1736
- }
1737
- message.optimizeFor = reader.int32();
1738
- continue;
1739
- }
1740
- case 11: {
1741
- if (tag !== 90) {
1742
- break;
1743
- }
1744
- message.goPackage = reader.string();
1745
- continue;
1746
- }
1747
- case 16: {
1748
- if (tag !== 128) {
1749
- break;
1750
- }
1751
- message.ccGenericServices = reader.bool();
1752
- continue;
1753
- }
1754
- case 17: {
1755
- if (tag !== 136) {
1756
- break;
1757
- }
1758
- message.javaGenericServices = reader.bool();
1759
- continue;
1760
- }
1761
- case 18: {
1762
- if (tag !== 144) {
1763
- break;
1764
- }
1765
- message.pyGenericServices = reader.bool();
1766
- continue;
1767
- }
1768
- case 23: {
1769
- if (tag !== 184) {
1770
- break;
1771
- }
1772
- message.deprecated = reader.bool();
1773
- continue;
1774
- }
1775
- case 31: {
1776
- if (tag !== 248) {
1777
- break;
1778
- }
1779
- message.ccEnableArenas = reader.bool();
1780
- continue;
1781
- }
1782
- case 36: {
1783
- if (tag !== 290) {
1784
- break;
1785
- }
1786
- message.objcClassPrefix = reader.string();
1787
- continue;
1788
- }
1789
- case 37: {
1790
- if (tag !== 298) {
1791
- break;
1792
- }
1793
- message.csharpNamespace = reader.string();
1794
- continue;
1795
- }
1796
- case 39: {
1797
- if (tag !== 314) {
1798
- break;
1799
- }
1800
- message.swiftPrefix = reader.string();
1801
- continue;
1802
- }
1803
- case 40: {
1804
- if (tag !== 322) {
1805
- break;
1806
- }
1807
- message.phpClassPrefix = reader.string();
1808
- continue;
1809
- }
1810
- case 41: {
1811
- if (tag !== 330) {
1812
- break;
1813
- }
1814
- message.phpNamespace = reader.string();
1815
- continue;
1816
- }
1817
- case 44: {
1818
- if (tag !== 354) {
1819
- break;
1820
- }
1821
- message.phpMetadataNamespace = reader.string();
1822
- continue;
1823
- }
1824
- case 45: {
1825
- if (tag !== 362) {
1826
- break;
1827
- }
1828
- message.rubyPackage = reader.string();
1829
- continue;
1830
- }
1831
- case 50: {
1832
- if (tag !== 402) {
1833
- break;
1834
- }
1835
- message.features = FeatureSet.decode(reader, reader.uint32());
1836
- continue;
1837
- }
1838
- case 999: {
1839
- if (tag !== 7994) {
1840
- break;
1841
- }
1842
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
1843
- continue;
1844
- }
1845
- }
1846
- if ((tag & 7) === 4 || tag === 0) {
1847
- break;
1848
- }
1849
- reader.skip(tag & 7);
1850
- }
1851
- return message;
1852
- },
1853
- create(base) {
1854
- return FileOptions.fromPartial(base ?? {});
1855
- },
1856
- fromPartial(object) {
1857
- const message = createBaseFileOptions();
1858
- message.javaPackage = object.javaPackage ?? "";
1859
- message.javaOuterClassname = object.javaOuterClassname ?? "";
1860
- message.javaMultipleFiles = object.javaMultipleFiles ?? false;
1861
- message.javaGenerateEqualsAndHash = object.javaGenerateEqualsAndHash ?? false;
1862
- message.javaStringCheckUtf8 = object.javaStringCheckUtf8 ?? false;
1863
- message.optimizeFor = object.optimizeFor ?? 1;
1864
- message.goPackage = object.goPackage ?? "";
1865
- message.ccGenericServices = object.ccGenericServices ?? false;
1866
- message.javaGenericServices = object.javaGenericServices ?? false;
1867
- message.pyGenericServices = object.pyGenericServices ?? false;
1868
- message.deprecated = object.deprecated ?? false;
1869
- message.ccEnableArenas = object.ccEnableArenas ?? true;
1870
- message.objcClassPrefix = object.objcClassPrefix ?? "";
1871
- message.csharpNamespace = object.csharpNamespace ?? "";
1872
- message.swiftPrefix = object.swiftPrefix ?? "";
1873
- message.phpClassPrefix = object.phpClassPrefix ?? "";
1874
- message.phpNamespace = object.phpNamespace ?? "";
1875
- message.phpMetadataNamespace = object.phpMetadataNamespace ?? "";
1876
- message.rubyPackage = object.rubyPackage ?? "";
1877
- message.features = (object.features !== undefined && object.features !== null)
1878
- ? FeatureSet.fromPartial(object.features)
1879
- : undefined;
1880
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
1881
- return message;
1882
- },
1883
- };
1884
- function createBaseMessageOptions() {
1885
- return {
1886
- messageSetWireFormat: false,
1887
- noStandardDescriptorAccessor: false,
1888
- deprecated: false,
1889
- mapEntry: false,
1890
- deprecatedLegacyJsonFieldConflicts: false,
1891
- features: undefined,
1892
- uninterpretedOption: [],
1893
- };
1894
- }
1895
- export const MessageOptions = {
1896
- encode(message, writer = new BinaryWriter()) {
1897
- if (message.messageSetWireFormat !== undefined && message.messageSetWireFormat !== false) {
1898
- writer.uint32(8).bool(message.messageSetWireFormat);
1899
- }
1900
- if (message.noStandardDescriptorAccessor !== undefined && message.noStandardDescriptorAccessor !== false) {
1901
- writer.uint32(16).bool(message.noStandardDescriptorAccessor);
1902
- }
1903
- if (message.deprecated !== undefined && message.deprecated !== false) {
1904
- writer.uint32(24).bool(message.deprecated);
1905
- }
1906
- if (message.mapEntry !== undefined && message.mapEntry !== false) {
1907
- writer.uint32(56).bool(message.mapEntry);
1908
- }
1909
- if (message.deprecatedLegacyJsonFieldConflicts !== undefined && message.deprecatedLegacyJsonFieldConflicts !== false) {
1910
- writer.uint32(88).bool(message.deprecatedLegacyJsonFieldConflicts);
1911
- }
1912
- if (message.features !== undefined) {
1913
- FeatureSet.encode(message.features, writer.uint32(98).fork()).join();
1914
- }
1915
- for (const v of message.uninterpretedOption) {
1916
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
1917
- }
1918
- return writer;
1919
- },
1920
- decode(input, length) {
1921
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
1922
- const end = length === undefined ? reader.len : reader.pos + length;
1923
- const message = createBaseMessageOptions();
1924
- while (reader.pos < end) {
1925
- const tag = reader.uint32();
1926
- switch (tag >>> 3) {
1927
- case 1: {
1928
- if (tag !== 8) {
1929
- break;
1930
- }
1931
- message.messageSetWireFormat = reader.bool();
1932
- continue;
1933
- }
1934
- case 2: {
1935
- if (tag !== 16) {
1936
- break;
1937
- }
1938
- message.noStandardDescriptorAccessor = reader.bool();
1939
- continue;
1940
- }
1941
- case 3: {
1942
- if (tag !== 24) {
1943
- break;
1944
- }
1945
- message.deprecated = reader.bool();
1946
- continue;
1947
- }
1948
- case 7: {
1949
- if (tag !== 56) {
1950
- break;
1951
- }
1952
- message.mapEntry = reader.bool();
1953
- continue;
1954
- }
1955
- case 11: {
1956
- if (tag !== 88) {
1957
- break;
1958
- }
1959
- message.deprecatedLegacyJsonFieldConflicts = reader.bool();
1960
- continue;
1961
- }
1962
- case 12: {
1963
- if (tag !== 98) {
1964
- break;
1965
- }
1966
- message.features = FeatureSet.decode(reader, reader.uint32());
1967
- continue;
1968
- }
1969
- case 999: {
1970
- if (tag !== 7994) {
1971
- break;
1972
- }
1973
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
1974
- continue;
1975
- }
1976
- }
1977
- if ((tag & 7) === 4 || tag === 0) {
1978
- break;
1979
- }
1980
- reader.skip(tag & 7);
1981
- }
1982
- return message;
1983
- },
1984
- create(base) {
1985
- return MessageOptions.fromPartial(base ?? {});
1986
- },
1987
- fromPartial(object) {
1988
- const message = createBaseMessageOptions();
1989
- message.messageSetWireFormat = object.messageSetWireFormat ?? false;
1990
- message.noStandardDescriptorAccessor = object.noStandardDescriptorAccessor ?? false;
1991
- message.deprecated = object.deprecated ?? false;
1992
- message.mapEntry = object.mapEntry ?? false;
1993
- message.deprecatedLegacyJsonFieldConflicts = object.deprecatedLegacyJsonFieldConflicts ?? false;
1994
- message.features = (object.features !== undefined && object.features !== null)
1995
- ? FeatureSet.fromPartial(object.features)
1996
- : undefined;
1997
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
1998
- return message;
1999
- },
2000
- };
2001
- function createBaseFieldOptions() {
2002
- return {
2003
- ctype: 0,
2004
- packed: false,
2005
- jstype: 0,
2006
- lazy: false,
2007
- unverifiedLazy: false,
2008
- deprecated: false,
2009
- weak: false,
2010
- debugRedact: false,
2011
- retention: 0,
2012
- targets: [],
2013
- editionDefaults: [],
2014
- features: undefined,
2015
- featureSupport: undefined,
2016
- uninterpretedOption: [],
2017
- };
2018
- }
2019
- export const FieldOptions = {
2020
- encode(message, writer = new BinaryWriter()) {
2021
- if (message.ctype !== undefined && message.ctype !== 0) {
2022
- writer.uint32(8).int32(message.ctype);
2023
- }
2024
- if (message.packed !== undefined && message.packed !== false) {
2025
- writer.uint32(16).bool(message.packed);
2026
- }
2027
- if (message.jstype !== undefined && message.jstype !== 0) {
2028
- writer.uint32(48).int32(message.jstype);
2029
- }
2030
- if (message.lazy !== undefined && message.lazy !== false) {
2031
- writer.uint32(40).bool(message.lazy);
2032
- }
2033
- if (message.unverifiedLazy !== undefined && message.unverifiedLazy !== false) {
2034
- writer.uint32(120).bool(message.unverifiedLazy);
2035
- }
2036
- if (message.deprecated !== undefined && message.deprecated !== false) {
2037
- writer.uint32(24).bool(message.deprecated);
2038
- }
2039
- if (message.weak !== undefined && message.weak !== false) {
2040
- writer.uint32(80).bool(message.weak);
2041
- }
2042
- if (message.debugRedact !== undefined && message.debugRedact !== false) {
2043
- writer.uint32(128).bool(message.debugRedact);
2044
- }
2045
- if (message.retention !== undefined && message.retention !== 0) {
2046
- writer.uint32(136).int32(message.retention);
2047
- }
2048
- for (const v of message.targets) {
2049
- writer.uint32(152).int32(v);
2050
- }
2051
- for (const v of message.editionDefaults) {
2052
- FieldOptions_EditionDefault.encode(v, writer.uint32(162).fork()).join();
2053
- }
2054
- if (message.features !== undefined) {
2055
- FeatureSet.encode(message.features, writer.uint32(170).fork()).join();
2056
- }
2057
- if (message.featureSupport !== undefined) {
2058
- FieldOptions_FeatureSupport.encode(message.featureSupport, writer.uint32(178).fork()).join();
2059
- }
2060
- for (const v of message.uninterpretedOption) {
2061
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
2062
- }
2063
- return writer;
2064
- },
2065
- decode(input, length) {
2066
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2067
- const end = length === undefined ? reader.len : reader.pos + length;
2068
- const message = createBaseFieldOptions();
2069
- while (reader.pos < end) {
2070
- const tag = reader.uint32();
2071
- switch (tag >>> 3) {
2072
- case 1: {
2073
- if (tag !== 8) {
2074
- break;
2075
- }
2076
- message.ctype = reader.int32();
2077
- continue;
2078
- }
2079
- case 2: {
2080
- if (tag !== 16) {
2081
- break;
2082
- }
2083
- message.packed = reader.bool();
2084
- continue;
2085
- }
2086
- case 6: {
2087
- if (tag !== 48) {
2088
- break;
2089
- }
2090
- message.jstype = reader.int32();
2091
- continue;
2092
- }
2093
- case 5: {
2094
- if (tag !== 40) {
2095
- break;
2096
- }
2097
- message.lazy = reader.bool();
2098
- continue;
2099
- }
2100
- case 15: {
2101
- if (tag !== 120) {
2102
- break;
2103
- }
2104
- message.unverifiedLazy = reader.bool();
2105
- continue;
2106
- }
2107
- case 3: {
2108
- if (tag !== 24) {
2109
- break;
2110
- }
2111
- message.deprecated = reader.bool();
2112
- continue;
2113
- }
2114
- case 10: {
2115
- if (tag !== 80) {
2116
- break;
2117
- }
2118
- message.weak = reader.bool();
2119
- continue;
2120
- }
2121
- case 16: {
2122
- if (tag !== 128) {
2123
- break;
2124
- }
2125
- message.debugRedact = reader.bool();
2126
- continue;
2127
- }
2128
- case 17: {
2129
- if (tag !== 136) {
2130
- break;
2131
- }
2132
- message.retention = reader.int32();
2133
- continue;
2134
- }
2135
- case 19: {
2136
- if (tag === 152) {
2137
- message.targets.push(reader.int32());
2138
- continue;
2139
- }
2140
- if (tag === 154) {
2141
- const end2 = reader.uint32() + reader.pos;
2142
- while (reader.pos < end2) {
2143
- message.targets.push(reader.int32());
2144
- }
2145
- continue;
2146
- }
2147
- break;
2148
- }
2149
- case 20: {
2150
- if (tag !== 162) {
2151
- break;
2152
- }
2153
- message.editionDefaults.push(FieldOptions_EditionDefault.decode(reader, reader.uint32()));
2154
- continue;
2155
- }
2156
- case 21: {
2157
- if (tag !== 170) {
2158
- break;
2159
- }
2160
- message.features = FeatureSet.decode(reader, reader.uint32());
2161
- continue;
2162
- }
2163
- case 22: {
2164
- if (tag !== 178) {
2165
- break;
2166
- }
2167
- message.featureSupport = FieldOptions_FeatureSupport.decode(reader, reader.uint32());
2168
- continue;
2169
- }
2170
- case 999: {
2171
- if (tag !== 7994) {
2172
- break;
2173
- }
2174
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
2175
- continue;
2176
- }
2177
- }
2178
- if ((tag & 7) === 4 || tag === 0) {
2179
- break;
2180
- }
2181
- reader.skip(tag & 7);
2182
- }
2183
- return message;
2184
- },
2185
- create(base) {
2186
- return FieldOptions.fromPartial(base ?? {});
2187
- },
2188
- fromPartial(object) {
2189
- const message = createBaseFieldOptions();
2190
- message.ctype = object.ctype ?? 0;
2191
- message.packed = object.packed ?? false;
2192
- message.jstype = object.jstype ?? 0;
2193
- message.lazy = object.lazy ?? false;
2194
- message.unverifiedLazy = object.unverifiedLazy ?? false;
2195
- message.deprecated = object.deprecated ?? false;
2196
- message.weak = object.weak ?? false;
2197
- message.debugRedact = object.debugRedact ?? false;
2198
- message.retention = object.retention ?? 0;
2199
- message.targets = object.targets?.map((e) => e) || [];
2200
- message.editionDefaults = object.editionDefaults?.map((e) => FieldOptions_EditionDefault.fromPartial(e)) || [];
2201
- message.features = (object.features !== undefined && object.features !== null)
2202
- ? FeatureSet.fromPartial(object.features)
2203
- : undefined;
2204
- message.featureSupport = (object.featureSupport !== undefined && object.featureSupport !== null)
2205
- ? FieldOptions_FeatureSupport.fromPartial(object.featureSupport)
2206
- : undefined;
2207
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
2208
- return message;
2209
- },
2210
- };
2211
- function createBaseFieldOptions_EditionDefault() {
2212
- return { edition: 0, value: "" };
2213
- }
2214
- export const FieldOptions_EditionDefault = {
2215
- encode(message, writer = new BinaryWriter()) {
2216
- if (message.edition !== undefined && message.edition !== 0) {
2217
- writer.uint32(24).int32(message.edition);
2218
- }
2219
- if (message.value !== undefined && message.value !== "") {
2220
- writer.uint32(18).string(message.value);
2221
- }
2222
- return writer;
2223
- },
2224
- decode(input, length) {
2225
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2226
- const end = length === undefined ? reader.len : reader.pos + length;
2227
- const message = createBaseFieldOptions_EditionDefault();
2228
- while (reader.pos < end) {
2229
- const tag = reader.uint32();
2230
- switch (tag >>> 3) {
2231
- case 3: {
2232
- if (tag !== 24) {
2233
- break;
2234
- }
2235
- message.edition = reader.int32();
2236
- continue;
2237
- }
2238
- case 2: {
2239
- if (tag !== 18) {
2240
- break;
2241
- }
2242
- message.value = reader.string();
2243
- continue;
2244
- }
2245
- }
2246
- if ((tag & 7) === 4 || tag === 0) {
2247
- break;
2248
- }
2249
- reader.skip(tag & 7);
2250
- }
2251
- return message;
2252
- },
2253
- create(base) {
2254
- return FieldOptions_EditionDefault.fromPartial(base ?? {});
2255
- },
2256
- fromPartial(object) {
2257
- const message = createBaseFieldOptions_EditionDefault();
2258
- message.edition = object.edition ?? 0;
2259
- message.value = object.value ?? "";
2260
- return message;
2261
- },
2262
- };
2263
- function createBaseFieldOptions_FeatureSupport() {
2264
- return { editionIntroduced: 0, editionDeprecated: 0, deprecationWarning: "", editionRemoved: 0, removalError: "" };
2265
- }
2266
- export const FieldOptions_FeatureSupport = {
2267
- encode(message, writer = new BinaryWriter()) {
2268
- if (message.editionIntroduced !== undefined && message.editionIntroduced !== 0) {
2269
- writer.uint32(8).int32(message.editionIntroduced);
2270
- }
2271
- if (message.editionDeprecated !== undefined && message.editionDeprecated !== 0) {
2272
- writer.uint32(16).int32(message.editionDeprecated);
2273
- }
2274
- if (message.deprecationWarning !== undefined && message.deprecationWarning !== "") {
2275
- writer.uint32(26).string(message.deprecationWarning);
2276
- }
2277
- if (message.editionRemoved !== undefined && message.editionRemoved !== 0) {
2278
- writer.uint32(32).int32(message.editionRemoved);
2279
- }
2280
- if (message.removalError !== undefined && message.removalError !== "") {
2281
- writer.uint32(42).string(message.removalError);
2282
- }
2283
- return writer;
2284
- },
2285
- decode(input, length) {
2286
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2287
- const end = length === undefined ? reader.len : reader.pos + length;
2288
- const message = createBaseFieldOptions_FeatureSupport();
2289
- while (reader.pos < end) {
2290
- const tag = reader.uint32();
2291
- switch (tag >>> 3) {
2292
- case 1: {
2293
- if (tag !== 8) {
2294
- break;
2295
- }
2296
- message.editionIntroduced = reader.int32();
2297
- continue;
2298
- }
2299
- case 2: {
2300
- if (tag !== 16) {
2301
- break;
2302
- }
2303
- message.editionDeprecated = reader.int32();
2304
- continue;
2305
- }
2306
- case 3: {
2307
- if (tag !== 26) {
2308
- break;
2309
- }
2310
- message.deprecationWarning = reader.string();
2311
- continue;
2312
- }
2313
- case 4: {
2314
- if (tag !== 32) {
2315
- break;
2316
- }
2317
- message.editionRemoved = reader.int32();
2318
- continue;
2319
- }
2320
- case 5: {
2321
- if (tag !== 42) {
2322
- break;
2323
- }
2324
- message.removalError = reader.string();
2325
- continue;
2326
- }
2327
- }
2328
- if ((tag & 7) === 4 || tag === 0) {
2329
- break;
2330
- }
2331
- reader.skip(tag & 7);
2332
- }
2333
- return message;
2334
- },
2335
- create(base) {
2336
- return FieldOptions_FeatureSupport.fromPartial(base ?? {});
2337
- },
2338
- fromPartial(object) {
2339
- const message = createBaseFieldOptions_FeatureSupport();
2340
- message.editionIntroduced = object.editionIntroduced ?? 0;
2341
- message.editionDeprecated = object.editionDeprecated ?? 0;
2342
- message.deprecationWarning = object.deprecationWarning ?? "";
2343
- message.editionRemoved = object.editionRemoved ?? 0;
2344
- message.removalError = object.removalError ?? "";
2345
- return message;
2346
- },
2347
- };
2348
- function createBaseOneofOptions() {
2349
- return { features: undefined, uninterpretedOption: [] };
2350
- }
2351
- export const OneofOptions = {
2352
- encode(message, writer = new BinaryWriter()) {
2353
- if (message.features !== undefined) {
2354
- FeatureSet.encode(message.features, writer.uint32(10).fork()).join();
2355
- }
2356
- for (const v of message.uninterpretedOption) {
2357
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
2358
- }
2359
- return writer;
2360
- },
2361
- decode(input, length) {
2362
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2363
- const end = length === undefined ? reader.len : reader.pos + length;
2364
- const message = createBaseOneofOptions();
2365
- while (reader.pos < end) {
2366
- const tag = reader.uint32();
2367
- switch (tag >>> 3) {
2368
- case 1: {
2369
- if (tag !== 10) {
2370
- break;
2371
- }
2372
- message.features = FeatureSet.decode(reader, reader.uint32());
2373
- continue;
2374
- }
2375
- case 999: {
2376
- if (tag !== 7994) {
2377
- break;
2378
- }
2379
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
2380
- continue;
2381
- }
2382
- }
2383
- if ((tag & 7) === 4 || tag === 0) {
2384
- break;
2385
- }
2386
- reader.skip(tag & 7);
2387
- }
2388
- return message;
2389
- },
2390
- create(base) {
2391
- return OneofOptions.fromPartial(base ?? {});
2392
- },
2393
- fromPartial(object) {
2394
- const message = createBaseOneofOptions();
2395
- message.features = (object.features !== undefined && object.features !== null)
2396
- ? FeatureSet.fromPartial(object.features)
2397
- : undefined;
2398
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
2399
- return message;
2400
- },
2401
- };
2402
- function createBaseEnumOptions() {
2403
- return {
2404
- allowAlias: false,
2405
- deprecated: false,
2406
- deprecatedLegacyJsonFieldConflicts: false,
2407
- features: undefined,
2408
- uninterpretedOption: [],
2409
- };
2410
- }
2411
- export const EnumOptions = {
2412
- encode(message, writer = new BinaryWriter()) {
2413
- if (message.allowAlias !== undefined && message.allowAlias !== false) {
2414
- writer.uint32(16).bool(message.allowAlias);
2415
- }
2416
- if (message.deprecated !== undefined && message.deprecated !== false) {
2417
- writer.uint32(24).bool(message.deprecated);
2418
- }
2419
- if (message.deprecatedLegacyJsonFieldConflicts !== undefined && message.deprecatedLegacyJsonFieldConflicts !== false) {
2420
- writer.uint32(48).bool(message.deprecatedLegacyJsonFieldConflicts);
2421
- }
2422
- if (message.features !== undefined) {
2423
- FeatureSet.encode(message.features, writer.uint32(58).fork()).join();
2424
- }
2425
- for (const v of message.uninterpretedOption) {
2426
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
2427
- }
2428
- return writer;
2429
- },
2430
- decode(input, length) {
2431
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2432
- const end = length === undefined ? reader.len : reader.pos + length;
2433
- const message = createBaseEnumOptions();
2434
- while (reader.pos < end) {
2435
- const tag = reader.uint32();
2436
- switch (tag >>> 3) {
2437
- case 2: {
2438
- if (tag !== 16) {
2439
- break;
2440
- }
2441
- message.allowAlias = reader.bool();
2442
- continue;
2443
- }
2444
- case 3: {
2445
- if (tag !== 24) {
2446
- break;
2447
- }
2448
- message.deprecated = reader.bool();
2449
- continue;
2450
- }
2451
- case 6: {
2452
- if (tag !== 48) {
2453
- break;
2454
- }
2455
- message.deprecatedLegacyJsonFieldConflicts = reader.bool();
2456
- continue;
2457
- }
2458
- case 7: {
2459
- if (tag !== 58) {
2460
- break;
2461
- }
2462
- message.features = FeatureSet.decode(reader, reader.uint32());
2463
- continue;
2464
- }
2465
- case 999: {
2466
- if (tag !== 7994) {
2467
- break;
2468
- }
2469
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
2470
- continue;
2471
- }
2472
- }
2473
- if ((tag & 7) === 4 || tag === 0) {
2474
- break;
2475
- }
2476
- reader.skip(tag & 7);
2477
- }
2478
- return message;
2479
- },
2480
- create(base) {
2481
- return EnumOptions.fromPartial(base ?? {});
2482
- },
2483
- fromPartial(object) {
2484
- const message = createBaseEnumOptions();
2485
- message.allowAlias = object.allowAlias ?? false;
2486
- message.deprecated = object.deprecated ?? false;
2487
- message.deprecatedLegacyJsonFieldConflicts = object.deprecatedLegacyJsonFieldConflicts ?? false;
2488
- message.features = (object.features !== undefined && object.features !== null)
2489
- ? FeatureSet.fromPartial(object.features)
2490
- : undefined;
2491
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
2492
- return message;
2493
- },
2494
- };
2495
- function createBaseEnumValueOptions() {
2496
- return {
2497
- deprecated: false,
2498
- features: undefined,
2499
- debugRedact: false,
2500
- featureSupport: undefined,
2501
- uninterpretedOption: [],
2502
- };
2503
- }
2504
- export const EnumValueOptions = {
2505
- encode(message, writer = new BinaryWriter()) {
2506
- if (message.deprecated !== undefined && message.deprecated !== false) {
2507
- writer.uint32(8).bool(message.deprecated);
2508
- }
2509
- if (message.features !== undefined) {
2510
- FeatureSet.encode(message.features, writer.uint32(18).fork()).join();
2511
- }
2512
- if (message.debugRedact !== undefined && message.debugRedact !== false) {
2513
- writer.uint32(24).bool(message.debugRedact);
2514
- }
2515
- if (message.featureSupport !== undefined) {
2516
- FieldOptions_FeatureSupport.encode(message.featureSupport, writer.uint32(34).fork()).join();
2517
- }
2518
- for (const v of message.uninterpretedOption) {
2519
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
2520
- }
2521
- return writer;
2522
- },
2523
- decode(input, length) {
2524
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2525
- const end = length === undefined ? reader.len : reader.pos + length;
2526
- const message = createBaseEnumValueOptions();
2527
- while (reader.pos < end) {
2528
- const tag = reader.uint32();
2529
- switch (tag >>> 3) {
2530
- case 1: {
2531
- if (tag !== 8) {
2532
- break;
2533
- }
2534
- message.deprecated = reader.bool();
2535
- continue;
2536
- }
2537
- case 2: {
2538
- if (tag !== 18) {
2539
- break;
2540
- }
2541
- message.features = FeatureSet.decode(reader, reader.uint32());
2542
- continue;
2543
- }
2544
- case 3: {
2545
- if (tag !== 24) {
2546
- break;
2547
- }
2548
- message.debugRedact = reader.bool();
2549
- continue;
2550
- }
2551
- case 4: {
2552
- if (tag !== 34) {
2553
- break;
2554
- }
2555
- message.featureSupport = FieldOptions_FeatureSupport.decode(reader, reader.uint32());
2556
- continue;
2557
- }
2558
- case 999: {
2559
- if (tag !== 7994) {
2560
- break;
2561
- }
2562
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
2563
- continue;
2564
- }
2565
- }
2566
- if ((tag & 7) === 4 || tag === 0) {
2567
- break;
2568
- }
2569
- reader.skip(tag & 7);
2570
- }
2571
- return message;
2572
- },
2573
- create(base) {
2574
- return EnumValueOptions.fromPartial(base ?? {});
2575
- },
2576
- fromPartial(object) {
2577
- const message = createBaseEnumValueOptions();
2578
- message.deprecated = object.deprecated ?? false;
2579
- message.features = (object.features !== undefined && object.features !== null)
2580
- ? FeatureSet.fromPartial(object.features)
2581
- : undefined;
2582
- message.debugRedact = object.debugRedact ?? false;
2583
- message.featureSupport = (object.featureSupport !== undefined && object.featureSupport !== null)
2584
- ? FieldOptions_FeatureSupport.fromPartial(object.featureSupport)
2585
- : undefined;
2586
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
2587
- return message;
2588
- },
2589
- };
2590
- function createBaseServiceOptions() {
2591
- return { features: undefined, deprecated: false, uninterpretedOption: [] };
2592
- }
2593
- export const ServiceOptions = {
2594
- encode(message, writer = new BinaryWriter()) {
2595
- if (message.features !== undefined) {
2596
- FeatureSet.encode(message.features, writer.uint32(274).fork()).join();
2597
- }
2598
- if (message.deprecated !== undefined && message.deprecated !== false) {
2599
- writer.uint32(264).bool(message.deprecated);
2600
- }
2601
- for (const v of message.uninterpretedOption) {
2602
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
2603
- }
2604
- return writer;
2605
- },
2606
- decode(input, length) {
2607
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2608
- const end = length === undefined ? reader.len : reader.pos + length;
2609
- const message = createBaseServiceOptions();
2610
- while (reader.pos < end) {
2611
- const tag = reader.uint32();
2612
- switch (tag >>> 3) {
2613
- case 34: {
2614
- if (tag !== 274) {
2615
- break;
2616
- }
2617
- message.features = FeatureSet.decode(reader, reader.uint32());
2618
- continue;
2619
- }
2620
- case 33: {
2621
- if (tag !== 264) {
2622
- break;
2623
- }
2624
- message.deprecated = reader.bool();
2625
- continue;
2626
- }
2627
- case 999: {
2628
- if (tag !== 7994) {
2629
- break;
2630
- }
2631
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
2632
- continue;
2633
- }
2634
- }
2635
- if ((tag & 7) === 4 || tag === 0) {
2636
- break;
2637
- }
2638
- reader.skip(tag & 7);
2639
- }
2640
- return message;
2641
- },
2642
- create(base) {
2643
- return ServiceOptions.fromPartial(base ?? {});
2644
- },
2645
- fromPartial(object) {
2646
- const message = createBaseServiceOptions();
2647
- message.features = (object.features !== undefined && object.features !== null)
2648
- ? FeatureSet.fromPartial(object.features)
2649
- : undefined;
2650
- message.deprecated = object.deprecated ?? false;
2651
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
2652
- return message;
2653
- },
2654
- };
2655
- function createBaseMethodOptions() {
2656
- return { deprecated: false, idempotencyLevel: 0, features: undefined, uninterpretedOption: [] };
2657
- }
2658
- export const MethodOptions = {
2659
- encode(message, writer = new BinaryWriter()) {
2660
- if (message.deprecated !== undefined && message.deprecated !== false) {
2661
- writer.uint32(264).bool(message.deprecated);
2662
- }
2663
- if (message.idempotencyLevel !== undefined && message.idempotencyLevel !== 0) {
2664
- writer.uint32(272).int32(message.idempotencyLevel);
2665
- }
2666
- if (message.features !== undefined) {
2667
- FeatureSet.encode(message.features, writer.uint32(282).fork()).join();
2668
- }
2669
- for (const v of message.uninterpretedOption) {
2670
- UninterpretedOption.encode(v, writer.uint32(7994).fork()).join();
2671
- }
2672
- return writer;
2673
- },
2674
- decode(input, length) {
2675
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2676
- const end = length === undefined ? reader.len : reader.pos + length;
2677
- const message = createBaseMethodOptions();
2678
- while (reader.pos < end) {
2679
- const tag = reader.uint32();
2680
- switch (tag >>> 3) {
2681
- case 33: {
2682
- if (tag !== 264) {
2683
- break;
2684
- }
2685
- message.deprecated = reader.bool();
2686
- continue;
2687
- }
2688
- case 34: {
2689
- if (tag !== 272) {
2690
- break;
2691
- }
2692
- message.idempotencyLevel = reader.int32();
2693
- continue;
2694
- }
2695
- case 35: {
2696
- if (tag !== 282) {
2697
- break;
2698
- }
2699
- message.features = FeatureSet.decode(reader, reader.uint32());
2700
- continue;
2701
- }
2702
- case 999: {
2703
- if (tag !== 7994) {
2704
- break;
2705
- }
2706
- message.uninterpretedOption.push(UninterpretedOption.decode(reader, reader.uint32()));
2707
- continue;
2708
- }
2709
- }
2710
- if ((tag & 7) === 4 || tag === 0) {
2711
- break;
2712
- }
2713
- reader.skip(tag & 7);
2714
- }
2715
- return message;
2716
- },
2717
- create(base) {
2718
- return MethodOptions.fromPartial(base ?? {});
2719
- },
2720
- fromPartial(object) {
2721
- const message = createBaseMethodOptions();
2722
- message.deprecated = object.deprecated ?? false;
2723
- message.idempotencyLevel = object.idempotencyLevel ?? 0;
2724
- message.features = (object.features !== undefined && object.features !== null)
2725
- ? FeatureSet.fromPartial(object.features)
2726
- : undefined;
2727
- message.uninterpretedOption = object.uninterpretedOption?.map((e) => UninterpretedOption.fromPartial(e)) || [];
2728
- return message;
2729
- },
2730
- };
2731
- function createBaseUninterpretedOption() {
2732
- return {
2733
- name: [],
2734
- identifierValue: "",
2735
- positiveIntValue: Long.UZERO,
2736
- negativeIntValue: Long.ZERO,
2737
- doubleValue: 0,
2738
- stringValue: new Uint8Array(0),
2739
- aggregateValue: "",
2740
- };
2741
- }
2742
- export const UninterpretedOption = {
2743
- encode(message, writer = new BinaryWriter()) {
2744
- for (const v of message.name) {
2745
- UninterpretedOption_NamePart.encode(v, writer.uint32(18).fork()).join();
2746
- }
2747
- if (message.identifierValue !== undefined && message.identifierValue !== "") {
2748
- writer.uint32(26).string(message.identifierValue);
2749
- }
2750
- if (message.positiveIntValue !== undefined && !message.positiveIntValue.equals(Long.UZERO)) {
2751
- writer.uint32(32).uint64(message.positiveIntValue.toString());
2752
- }
2753
- if (message.negativeIntValue !== undefined && !message.negativeIntValue.equals(Long.ZERO)) {
2754
- writer.uint32(40).int64(message.negativeIntValue.toString());
2755
- }
2756
- if (message.doubleValue !== undefined && message.doubleValue !== 0) {
2757
- writer.uint32(49).double(message.doubleValue);
2758
- }
2759
- if (message.stringValue !== undefined && message.stringValue.length !== 0) {
2760
- writer.uint32(58).bytes(message.stringValue);
2761
- }
2762
- if (message.aggregateValue !== undefined && message.aggregateValue !== "") {
2763
- writer.uint32(66).string(message.aggregateValue);
2764
- }
2765
- return writer;
2766
- },
2767
- decode(input, length) {
2768
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2769
- const end = length === undefined ? reader.len : reader.pos + length;
2770
- const message = createBaseUninterpretedOption();
2771
- while (reader.pos < end) {
2772
- const tag = reader.uint32();
2773
- switch (tag >>> 3) {
2774
- case 2: {
2775
- if (tag !== 18) {
2776
- break;
2777
- }
2778
- message.name.push(UninterpretedOption_NamePart.decode(reader, reader.uint32()));
2779
- continue;
2780
- }
2781
- case 3: {
2782
- if (tag !== 26) {
2783
- break;
2784
- }
2785
- message.identifierValue = reader.string();
2786
- continue;
2787
- }
2788
- case 4: {
2789
- if (tag !== 32) {
2790
- break;
2791
- }
2792
- message.positiveIntValue = Long.fromString(reader.uint64().toString(), true);
2793
- continue;
2794
- }
2795
- case 5: {
2796
- if (tag !== 40) {
2797
- break;
2798
- }
2799
- message.negativeIntValue = Long.fromString(reader.int64().toString());
2800
- continue;
2801
- }
2802
- case 6: {
2803
- if (tag !== 49) {
2804
- break;
2805
- }
2806
- message.doubleValue = reader.double();
2807
- continue;
2808
- }
2809
- case 7: {
2810
- if (tag !== 58) {
2811
- break;
2812
- }
2813
- message.stringValue = reader.bytes();
2814
- continue;
2815
- }
2816
- case 8: {
2817
- if (tag !== 66) {
2818
- break;
2819
- }
2820
- message.aggregateValue = reader.string();
2821
- continue;
2822
- }
2823
- }
2824
- if ((tag & 7) === 4 || tag === 0) {
2825
- break;
2826
- }
2827
- reader.skip(tag & 7);
2828
- }
2829
- return message;
2830
- },
2831
- create(base) {
2832
- return UninterpretedOption.fromPartial(base ?? {});
2833
- },
2834
- fromPartial(object) {
2835
- const message = createBaseUninterpretedOption();
2836
- message.name = object.name?.map((e) => UninterpretedOption_NamePart.fromPartial(e)) || [];
2837
- message.identifierValue = object.identifierValue ?? "";
2838
- message.positiveIntValue = (object.positiveIntValue !== undefined && object.positiveIntValue !== null)
2839
- ? Long.fromValue(object.positiveIntValue)
2840
- : Long.UZERO;
2841
- message.negativeIntValue = (object.negativeIntValue !== undefined && object.negativeIntValue !== null)
2842
- ? Long.fromValue(object.negativeIntValue)
2843
- : Long.ZERO;
2844
- message.doubleValue = object.doubleValue ?? 0;
2845
- message.stringValue = object.stringValue ?? new Uint8Array(0);
2846
- message.aggregateValue = object.aggregateValue ?? "";
2847
- return message;
2848
- },
2849
- };
2850
- function createBaseUninterpretedOption_NamePart() {
2851
- return { namePart: "", isExtension: false };
2852
- }
2853
- export const UninterpretedOption_NamePart = {
2854
- encode(message, writer = new BinaryWriter()) {
2855
- if (message.namePart !== "") {
2856
- writer.uint32(10).string(message.namePart);
2857
- }
2858
- if (message.isExtension !== false) {
2859
- writer.uint32(16).bool(message.isExtension);
2860
- }
2861
- return writer;
2862
- },
2863
- decode(input, length) {
2864
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2865
- const end = length === undefined ? reader.len : reader.pos + length;
2866
- const message = createBaseUninterpretedOption_NamePart();
2867
- while (reader.pos < end) {
2868
- const tag = reader.uint32();
2869
- switch (tag >>> 3) {
2870
- case 1: {
2871
- if (tag !== 10) {
2872
- break;
2873
- }
2874
- message.namePart = reader.string();
2875
- continue;
2876
- }
2877
- case 2: {
2878
- if (tag !== 16) {
2879
- break;
2880
- }
2881
- message.isExtension = reader.bool();
2882
- continue;
2883
- }
2884
- }
2885
- if ((tag & 7) === 4 || tag === 0) {
2886
- break;
2887
- }
2888
- reader.skip(tag & 7);
2889
- }
2890
- return message;
2891
- },
2892
- create(base) {
2893
- return UninterpretedOption_NamePart.fromPartial(base ?? {});
2894
- },
2895
- fromPartial(object) {
2896
- const message = createBaseUninterpretedOption_NamePart();
2897
- message.namePart = object.namePart ?? "";
2898
- message.isExtension = object.isExtension ?? false;
2899
- return message;
2900
- },
2901
- };
2902
- function createBaseFeatureSet() {
2903
- return {
2904
- fieldPresence: 0,
2905
- enumType: 0,
2906
- repeatedFieldEncoding: 0,
2907
- utf8Validation: 0,
2908
- messageEncoding: 0,
2909
- jsonFormat: 0,
2910
- enforceNamingStyle: 0,
2911
- defaultSymbolVisibility: 0,
2912
- };
2913
- }
2914
- export const FeatureSet = {
2915
- encode(message, writer = new BinaryWriter()) {
2916
- if (message.fieldPresence !== undefined && message.fieldPresence !== 0) {
2917
- writer.uint32(8).int32(message.fieldPresence);
2918
- }
2919
- if (message.enumType !== undefined && message.enumType !== 0) {
2920
- writer.uint32(16).int32(message.enumType);
2921
- }
2922
- if (message.repeatedFieldEncoding !== undefined && message.repeatedFieldEncoding !== 0) {
2923
- writer.uint32(24).int32(message.repeatedFieldEncoding);
2924
- }
2925
- if (message.utf8Validation !== undefined && message.utf8Validation !== 0) {
2926
- writer.uint32(32).int32(message.utf8Validation);
2927
- }
2928
- if (message.messageEncoding !== undefined && message.messageEncoding !== 0) {
2929
- writer.uint32(40).int32(message.messageEncoding);
2930
- }
2931
- if (message.jsonFormat !== undefined && message.jsonFormat !== 0) {
2932
- writer.uint32(48).int32(message.jsonFormat);
2933
- }
2934
- if (message.enforceNamingStyle !== undefined && message.enforceNamingStyle !== 0) {
2935
- writer.uint32(56).int32(message.enforceNamingStyle);
2936
- }
2937
- if (message.defaultSymbolVisibility !== undefined && message.defaultSymbolVisibility !== 0) {
2938
- writer.uint32(64).int32(message.defaultSymbolVisibility);
2939
- }
2940
- return writer;
2941
- },
2942
- decode(input, length) {
2943
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
2944
- const end = length === undefined ? reader.len : reader.pos + length;
2945
- const message = createBaseFeatureSet();
2946
- while (reader.pos < end) {
2947
- const tag = reader.uint32();
2948
- switch (tag >>> 3) {
2949
- case 1: {
2950
- if (tag !== 8) {
2951
- break;
2952
- }
2953
- message.fieldPresence = reader.int32();
2954
- continue;
2955
- }
2956
- case 2: {
2957
- if (tag !== 16) {
2958
- break;
2959
- }
2960
- message.enumType = reader.int32();
2961
- continue;
2962
- }
2963
- case 3: {
2964
- if (tag !== 24) {
2965
- break;
2966
- }
2967
- message.repeatedFieldEncoding = reader.int32();
2968
- continue;
2969
- }
2970
- case 4: {
2971
- if (tag !== 32) {
2972
- break;
2973
- }
2974
- message.utf8Validation = reader.int32();
2975
- continue;
2976
- }
2977
- case 5: {
2978
- if (tag !== 40) {
2979
- break;
2980
- }
2981
- message.messageEncoding = reader.int32();
2982
- continue;
2983
- }
2984
- case 6: {
2985
- if (tag !== 48) {
2986
- break;
2987
- }
2988
- message.jsonFormat = reader.int32();
2989
- continue;
2990
- }
2991
- case 7: {
2992
- if (tag !== 56) {
2993
- break;
2994
- }
2995
- message.enforceNamingStyle = reader.int32();
2996
- continue;
2997
- }
2998
- case 8: {
2999
- if (tag !== 64) {
3000
- break;
3001
- }
3002
- message.defaultSymbolVisibility = reader.int32();
3003
- continue;
3004
- }
3005
- }
3006
- if ((tag & 7) === 4 || tag === 0) {
3007
- break;
3008
- }
3009
- reader.skip(tag & 7);
3010
- }
3011
- return message;
3012
- },
3013
- create(base) {
3014
- return FeatureSet.fromPartial(base ?? {});
3015
- },
3016
- fromPartial(object) {
3017
- const message = createBaseFeatureSet();
3018
- message.fieldPresence = object.fieldPresence ?? 0;
3019
- message.enumType = object.enumType ?? 0;
3020
- message.repeatedFieldEncoding = object.repeatedFieldEncoding ?? 0;
3021
- message.utf8Validation = object.utf8Validation ?? 0;
3022
- message.messageEncoding = object.messageEncoding ?? 0;
3023
- message.jsonFormat = object.jsonFormat ?? 0;
3024
- message.enforceNamingStyle = object.enforceNamingStyle ?? 0;
3025
- message.defaultSymbolVisibility = object.defaultSymbolVisibility ?? 0;
3026
- return message;
3027
- },
3028
- };
3029
- function createBaseFeatureSet_VisibilityFeature() {
3030
- return {};
3031
- }
3032
- export const FeatureSet_VisibilityFeature = {
3033
- encode(_, writer = new BinaryWriter()) {
3034
- return writer;
3035
- },
3036
- decode(input, length) {
3037
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3038
- const end = length === undefined ? reader.len : reader.pos + length;
3039
- const message = createBaseFeatureSet_VisibilityFeature();
3040
- while (reader.pos < end) {
3041
- const tag = reader.uint32();
3042
- switch (tag >>> 3) {
3043
- }
3044
- if ((tag & 7) === 4 || tag === 0) {
3045
- break;
3046
- }
3047
- reader.skip(tag & 7);
3048
- }
3049
- return message;
3050
- },
3051
- create(base) {
3052
- return FeatureSet_VisibilityFeature.fromPartial(base ?? {});
3053
- },
3054
- fromPartial(_) {
3055
- const message = createBaseFeatureSet_VisibilityFeature();
3056
- return message;
3057
- },
3058
- };
3059
- function createBaseFeatureSetDefaults() {
3060
- return { defaults: [], minimumEdition: 0, maximumEdition: 0 };
3061
- }
3062
- export const FeatureSetDefaults = {
3063
- encode(message, writer = new BinaryWriter()) {
3064
- for (const v of message.defaults) {
3065
- FeatureSetDefaults_FeatureSetEditionDefault.encode(v, writer.uint32(10).fork()).join();
3066
- }
3067
- if (message.minimumEdition !== undefined && message.minimumEdition !== 0) {
3068
- writer.uint32(32).int32(message.minimumEdition);
3069
- }
3070
- if (message.maximumEdition !== undefined && message.maximumEdition !== 0) {
3071
- writer.uint32(40).int32(message.maximumEdition);
3072
- }
3073
- return writer;
3074
- },
3075
- decode(input, length) {
3076
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3077
- const end = length === undefined ? reader.len : reader.pos + length;
3078
- const message = createBaseFeatureSetDefaults();
3079
- while (reader.pos < end) {
3080
- const tag = reader.uint32();
3081
- switch (tag >>> 3) {
3082
- case 1: {
3083
- if (tag !== 10) {
3084
- break;
3085
- }
3086
- message.defaults.push(FeatureSetDefaults_FeatureSetEditionDefault.decode(reader, reader.uint32()));
3087
- continue;
3088
- }
3089
- case 4: {
3090
- if (tag !== 32) {
3091
- break;
3092
- }
3093
- message.minimumEdition = reader.int32();
3094
- continue;
3095
- }
3096
- case 5: {
3097
- if (tag !== 40) {
3098
- break;
3099
- }
3100
- message.maximumEdition = reader.int32();
3101
- continue;
3102
- }
3103
- }
3104
- if ((tag & 7) === 4 || tag === 0) {
3105
- break;
3106
- }
3107
- reader.skip(tag & 7);
3108
- }
3109
- return message;
3110
- },
3111
- create(base) {
3112
- return FeatureSetDefaults.fromPartial(base ?? {});
3113
- },
3114
- fromPartial(object) {
3115
- const message = createBaseFeatureSetDefaults();
3116
- message.defaults = object.defaults?.map((e) => FeatureSetDefaults_FeatureSetEditionDefault.fromPartial(e)) || [];
3117
- message.minimumEdition = object.minimumEdition ?? 0;
3118
- message.maximumEdition = object.maximumEdition ?? 0;
3119
- return message;
3120
- },
3121
- };
3122
- function createBaseFeatureSetDefaults_FeatureSetEditionDefault() {
3123
- return { edition: 0, overridableFeatures: undefined, fixedFeatures: undefined };
3124
- }
3125
- export const FeatureSetDefaults_FeatureSetEditionDefault = {
3126
- encode(message, writer = new BinaryWriter()) {
3127
- if (message.edition !== undefined && message.edition !== 0) {
3128
- writer.uint32(24).int32(message.edition);
3129
- }
3130
- if (message.overridableFeatures !== undefined) {
3131
- FeatureSet.encode(message.overridableFeatures, writer.uint32(34).fork()).join();
3132
- }
3133
- if (message.fixedFeatures !== undefined) {
3134
- FeatureSet.encode(message.fixedFeatures, writer.uint32(42).fork()).join();
3135
- }
3136
- return writer;
3137
- },
3138
- decode(input, length) {
3139
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3140
- const end = length === undefined ? reader.len : reader.pos + length;
3141
- const message = createBaseFeatureSetDefaults_FeatureSetEditionDefault();
3142
- while (reader.pos < end) {
3143
- const tag = reader.uint32();
3144
- switch (tag >>> 3) {
3145
- case 3: {
3146
- if (tag !== 24) {
3147
- break;
3148
- }
3149
- message.edition = reader.int32();
3150
- continue;
3151
- }
3152
- case 4: {
3153
- if (tag !== 34) {
3154
- break;
3155
- }
3156
- message.overridableFeatures = FeatureSet.decode(reader, reader.uint32());
3157
- continue;
3158
- }
3159
- case 5: {
3160
- if (tag !== 42) {
3161
- break;
3162
- }
3163
- message.fixedFeatures = FeatureSet.decode(reader, reader.uint32());
3164
- continue;
3165
- }
3166
- }
3167
- if ((tag & 7) === 4 || tag === 0) {
3168
- break;
3169
- }
3170
- reader.skip(tag & 7);
3171
- }
3172
- return message;
3173
- },
3174
- create(base) {
3175
- return FeatureSetDefaults_FeatureSetEditionDefault.fromPartial(base ?? {});
3176
- },
3177
- fromPartial(object) {
3178
- const message = createBaseFeatureSetDefaults_FeatureSetEditionDefault();
3179
- message.edition = object.edition ?? 0;
3180
- message.overridableFeatures = (object.overridableFeatures !== undefined && object.overridableFeatures !== null)
3181
- ? FeatureSet.fromPartial(object.overridableFeatures)
3182
- : undefined;
3183
- message.fixedFeatures = (object.fixedFeatures !== undefined && object.fixedFeatures !== null)
3184
- ? FeatureSet.fromPartial(object.fixedFeatures)
3185
- : undefined;
3186
- return message;
3187
- },
3188
- };
3189
- function createBaseSourceCodeInfo() {
3190
- return { location: [] };
3191
- }
3192
- export const SourceCodeInfo = {
3193
- encode(message, writer = new BinaryWriter()) {
3194
- for (const v of message.location) {
3195
- SourceCodeInfo_Location.encode(v, writer.uint32(10).fork()).join();
3196
- }
3197
- return writer;
3198
- },
3199
- decode(input, length) {
3200
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3201
- const end = length === undefined ? reader.len : reader.pos + length;
3202
- const message = createBaseSourceCodeInfo();
3203
- while (reader.pos < end) {
3204
- const tag = reader.uint32();
3205
- switch (tag >>> 3) {
3206
- case 1: {
3207
- if (tag !== 10) {
3208
- break;
3209
- }
3210
- message.location.push(SourceCodeInfo_Location.decode(reader, reader.uint32()));
3211
- continue;
3212
- }
3213
- }
3214
- if ((tag & 7) === 4 || tag === 0) {
3215
- break;
3216
- }
3217
- reader.skip(tag & 7);
3218
- }
3219
- return message;
3220
- },
3221
- create(base) {
3222
- return SourceCodeInfo.fromPartial(base ?? {});
3223
- },
3224
- fromPartial(object) {
3225
- const message = createBaseSourceCodeInfo();
3226
- message.location = object.location?.map((e) => SourceCodeInfo_Location.fromPartial(e)) || [];
3227
- return message;
3228
- },
3229
- };
3230
- function createBaseSourceCodeInfo_Location() {
3231
- return { path: [], span: [], leadingComments: "", trailingComments: "", leadingDetachedComments: [] };
3232
- }
3233
- export const SourceCodeInfo_Location = {
3234
- encode(message, writer = new BinaryWriter()) {
3235
- writer.uint32(10).fork();
3236
- for (const v of message.path) {
3237
- writer.int32(v);
3238
- }
3239
- writer.join();
3240
- writer.uint32(18).fork();
3241
- for (const v of message.span) {
3242
- writer.int32(v);
3243
- }
3244
- writer.join();
3245
- if (message.leadingComments !== undefined && message.leadingComments !== "") {
3246
- writer.uint32(26).string(message.leadingComments);
3247
- }
3248
- if (message.trailingComments !== undefined && message.trailingComments !== "") {
3249
- writer.uint32(34).string(message.trailingComments);
3250
- }
3251
- for (const v of message.leadingDetachedComments) {
3252
- writer.uint32(50).string(v);
3253
- }
3254
- return writer;
3255
- },
3256
- decode(input, length) {
3257
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3258
- const end = length === undefined ? reader.len : reader.pos + length;
3259
- const message = createBaseSourceCodeInfo_Location();
3260
- while (reader.pos < end) {
3261
- const tag = reader.uint32();
3262
- switch (tag >>> 3) {
3263
- case 1: {
3264
- if (tag === 8) {
3265
- message.path.push(reader.int32());
3266
- continue;
3267
- }
3268
- if (tag === 10) {
3269
- const end2 = reader.uint32() + reader.pos;
3270
- while (reader.pos < end2) {
3271
- message.path.push(reader.int32());
3272
- }
3273
- continue;
3274
- }
3275
- break;
3276
- }
3277
- case 2: {
3278
- if (tag === 16) {
3279
- message.span.push(reader.int32());
3280
- continue;
3281
- }
3282
- if (tag === 18) {
3283
- const end2 = reader.uint32() + reader.pos;
3284
- while (reader.pos < end2) {
3285
- message.span.push(reader.int32());
3286
- }
3287
- continue;
3288
- }
3289
- break;
3290
- }
3291
- case 3: {
3292
- if (tag !== 26) {
3293
- break;
3294
- }
3295
- message.leadingComments = reader.string();
3296
- continue;
3297
- }
3298
- case 4: {
3299
- if (tag !== 34) {
3300
- break;
3301
- }
3302
- message.trailingComments = reader.string();
3303
- continue;
3304
- }
3305
- case 6: {
3306
- if (tag !== 50) {
3307
- break;
3308
- }
3309
- message.leadingDetachedComments.push(reader.string());
3310
- continue;
3311
- }
3312
- }
3313
- if ((tag & 7) === 4 || tag === 0) {
3314
- break;
3315
- }
3316
- reader.skip(tag & 7);
3317
- }
3318
- return message;
3319
- },
3320
- create(base) {
3321
- return SourceCodeInfo_Location.fromPartial(base ?? {});
3322
- },
3323
- fromPartial(object) {
3324
- const message = createBaseSourceCodeInfo_Location();
3325
- message.path = object.path?.map((e) => e) || [];
3326
- message.span = object.span?.map((e) => e) || [];
3327
- message.leadingComments = object.leadingComments ?? "";
3328
- message.trailingComments = object.trailingComments ?? "";
3329
- message.leadingDetachedComments = object.leadingDetachedComments?.map((e) => e) || [];
3330
- return message;
3331
- },
3332
- };
3333
- function createBaseGeneratedCodeInfo() {
3334
- return { annotation: [] };
3335
- }
3336
- export const GeneratedCodeInfo = {
3337
- encode(message, writer = new BinaryWriter()) {
3338
- for (const v of message.annotation) {
3339
- GeneratedCodeInfo_Annotation.encode(v, writer.uint32(10).fork()).join();
3340
- }
3341
- return writer;
3342
- },
3343
- decode(input, length) {
3344
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3345
- const end = length === undefined ? reader.len : reader.pos + length;
3346
- const message = createBaseGeneratedCodeInfo();
3347
- while (reader.pos < end) {
3348
- const tag = reader.uint32();
3349
- switch (tag >>> 3) {
3350
- case 1: {
3351
- if (tag !== 10) {
3352
- break;
3353
- }
3354
- message.annotation.push(GeneratedCodeInfo_Annotation.decode(reader, reader.uint32()));
3355
- continue;
3356
- }
3357
- }
3358
- if ((tag & 7) === 4 || tag === 0) {
3359
- break;
3360
- }
3361
- reader.skip(tag & 7);
3362
- }
3363
- return message;
3364
- },
3365
- create(base) {
3366
- return GeneratedCodeInfo.fromPartial(base ?? {});
3367
- },
3368
- fromPartial(object) {
3369
- const message = createBaseGeneratedCodeInfo();
3370
- message.annotation = object.annotation?.map((e) => GeneratedCodeInfo_Annotation.fromPartial(e)) || [];
3371
- return message;
3372
- },
3373
- };
3374
- function createBaseGeneratedCodeInfo_Annotation() {
3375
- return { path: [], sourceFile: "", begin: 0, end: 0, semantic: 0 };
3376
- }
3377
- export const GeneratedCodeInfo_Annotation = {
3378
- encode(message, writer = new BinaryWriter()) {
3379
- writer.uint32(10).fork();
3380
- for (const v of message.path) {
3381
- writer.int32(v);
3382
- }
3383
- writer.join();
3384
- if (message.sourceFile !== undefined && message.sourceFile !== "") {
3385
- writer.uint32(18).string(message.sourceFile);
3386
- }
3387
- if (message.begin !== undefined && message.begin !== 0) {
3388
- writer.uint32(24).int32(message.begin);
3389
- }
3390
- if (message.end !== undefined && message.end !== 0) {
3391
- writer.uint32(32).int32(message.end);
3392
- }
3393
- if (message.semantic !== undefined && message.semantic !== 0) {
3394
- writer.uint32(40).int32(message.semantic);
3395
- }
3396
- return writer;
3397
- },
3398
- decode(input, length) {
3399
- const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
3400
- const end = length === undefined ? reader.len : reader.pos + length;
3401
- const message = createBaseGeneratedCodeInfo_Annotation();
3402
- while (reader.pos < end) {
3403
- const tag = reader.uint32();
3404
- switch (tag >>> 3) {
3405
- case 1: {
3406
- if (tag === 8) {
3407
- message.path.push(reader.int32());
3408
- continue;
3409
- }
3410
- if (tag === 10) {
3411
- const end2 = reader.uint32() + reader.pos;
3412
- while (reader.pos < end2) {
3413
- message.path.push(reader.int32());
3414
- }
3415
- continue;
3416
- }
3417
- break;
3418
- }
3419
- case 2: {
3420
- if (tag !== 18) {
3421
- break;
3422
- }
3423
- message.sourceFile = reader.string();
3424
- continue;
3425
- }
3426
- case 3: {
3427
- if (tag !== 24) {
3428
- break;
3429
- }
3430
- message.begin = reader.int32();
3431
- continue;
3432
- }
3433
- case 4: {
3434
- if (tag !== 32) {
3435
- break;
3436
- }
3437
- message.end = reader.int32();
3438
- continue;
3439
- }
3440
- case 5: {
3441
- if (tag !== 40) {
3442
- break;
3443
- }
3444
- message.semantic = reader.int32();
3445
- continue;
3446
- }
3447
- }
3448
- if ((tag & 7) === 4 || tag === 0) {
3449
- break;
3450
- }
3451
- reader.skip(tag & 7);
3452
- }
3453
- return message;
3454
- },
3455
- create(base) {
3456
- return GeneratedCodeInfo_Annotation.fromPartial(base ?? {});
3457
- },
3458
- fromPartial(object) {
3459
- const message = createBaseGeneratedCodeInfo_Annotation();
3460
- message.path = object.path?.map((e) => e) || [];
3461
- message.sourceFile = object.sourceFile ?? "";
3462
- message.begin = object.begin ?? 0;
3463
- message.end = object.end ?? 0;
3464
- message.semantic = object.semantic ?? 0;
3465
- return message;
3466
- },
3467
- };