@cerbos/grpc
Version:
Client library for interacting with the Cerbos policy decision point service over gRPC from server-side Node.js applications
1,419 lines • 119 kB
JavaScript
"use strict";
// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// source: buf/validate/validate.proto
Object.defineProperty(exports, "__esModule", { value: true });
exports.TimestampRules = exports.DurationRules = exports.AnyRules = exports.MapRules = exports.RepeatedRules = exports.EnumRules = exports.BytesRules = exports.StringRules = exports.BoolRules = exports.SFixed64Rules = exports.SFixed32Rules = exports.Fixed64Rules = exports.Fixed32Rules = exports.SInt64Rules = exports.SInt32Rules = exports.UInt64Rules = exports.UInt32Rules = exports.Int64Rules = exports.Int32Rules = exports.DoubleRules = exports.FloatRules = exports.PredefinedRules = exports.FieldRules = exports.OneofRules = exports.MessageRules = exports.Rule = exports.KnownRegex = exports.Ignore = exports.protobufPackage = void 0;
/* eslint-disable */
const wire_1 = require("@bufbuild/protobuf/wire");
const duration_1 = require("../../google/protobuf/duration");
const timestamp_1 = require("../../google/protobuf/timestamp");
exports.protobufPackage = "buf.validate";
var Ignore;
(function (Ignore) {
Ignore[Ignore["IGNORE_UNSPECIFIED"] = 0] = "IGNORE_UNSPECIFIED";
Ignore[Ignore["IGNORE_IF_UNPOPULATED"] = 1] = "IGNORE_IF_UNPOPULATED";
Ignore[Ignore["IGNORE_IF_DEFAULT_VALUE"] = 2] = "IGNORE_IF_DEFAULT_VALUE";
Ignore[Ignore["IGNORE_ALWAYS"] = 3] = "IGNORE_ALWAYS";
})(Ignore || (exports.Ignore = Ignore = {}));
var KnownRegex;
(function (KnownRegex) {
KnownRegex[KnownRegex["KNOWN_REGEX_UNSPECIFIED"] = 0] = "KNOWN_REGEX_UNSPECIFIED";
KnownRegex[KnownRegex["KNOWN_REGEX_HTTP_HEADER_NAME"] = 1] = "KNOWN_REGEX_HTTP_HEADER_NAME";
KnownRegex[KnownRegex["KNOWN_REGEX_HTTP_HEADER_VALUE"] = 2] = "KNOWN_REGEX_HTTP_HEADER_VALUE";
})(KnownRegex || (exports.KnownRegex = KnownRegex = {}));
function createBaseRule() {
return { id: "", message: "", expression: "" };
}
exports.Rule = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.id !== undefined && message.id !== "") {
writer.uint32(10).string(message.id);
}
if (message.message !== undefined && message.message !== "") {
writer.uint32(18).string(message.message);
}
if (message.expression !== undefined && message.expression !== "") {
writer.uint32(26).string(message.expression);
}
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRule();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 10) {
break;
}
message.id = reader.string();
continue;
}
case 2: {
if (tag !== 18) {
break;
}
message.message = reader.string();
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.expression = reader.string();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseMessageRules() {
return { disabled: false, cel: [] };
}
exports.MessageRules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.disabled !== undefined && message.disabled !== false) {
writer.uint32(8).bool(message.disabled);
}
for (const v of message.cel) {
exports.Rule.encode(v, writer.uint32(26).fork()).join();
}
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMessageRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.disabled = reader.bool();
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.cel.push(exports.Rule.decode(reader, reader.uint32()));
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseOneofRules() {
return { required: false };
}
exports.OneofRules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.required !== undefined && message.required !== false) {
writer.uint32(8).bool(message.required);
}
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseOneofRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.required = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseFieldRules() {
return { cel: [], required: false, ignore: 0, type: undefined };
}
exports.FieldRules = {
encode(message, writer = new wire_1.BinaryWriter()) {
for (const v of message.cel) {
exports.Rule.encode(v, writer.uint32(186).fork()).join();
}
if (message.required !== undefined && message.required !== false) {
writer.uint32(200).bool(message.required);
}
if (message.ignore !== undefined && message.ignore !== 0) {
writer.uint32(216).int32(message.ignore);
}
switch (message.type?.$case) {
case "float":
exports.FloatRules.encode(message.type.float, writer.uint32(10).fork()).join();
break;
case "double":
exports.DoubleRules.encode(message.type.double, writer.uint32(18).fork()).join();
break;
case "int32":
exports.Int32Rules.encode(message.type.int32, writer.uint32(26).fork()).join();
break;
case "int64":
exports.Int64Rules.encode(message.type.int64, writer.uint32(34).fork()).join();
break;
case "uint32":
exports.UInt32Rules.encode(message.type.uint32, writer.uint32(42).fork()).join();
break;
case "uint64":
exports.UInt64Rules.encode(message.type.uint64, writer.uint32(50).fork()).join();
break;
case "sint32":
exports.SInt32Rules.encode(message.type.sint32, writer.uint32(58).fork()).join();
break;
case "sint64":
exports.SInt64Rules.encode(message.type.sint64, writer.uint32(66).fork()).join();
break;
case "fixed32":
exports.Fixed32Rules.encode(message.type.fixed32, writer.uint32(74).fork()).join();
break;
case "fixed64":
exports.Fixed64Rules.encode(message.type.fixed64, writer.uint32(82).fork()).join();
break;
case "sfixed32":
exports.SFixed32Rules.encode(message.type.sfixed32, writer.uint32(90).fork()).join();
break;
case "sfixed64":
exports.SFixed64Rules.encode(message.type.sfixed64, writer.uint32(98).fork()).join();
break;
case "bool":
exports.BoolRules.encode(message.type.bool, writer.uint32(106).fork()).join();
break;
case "string":
exports.StringRules.encode(message.type.string, writer.uint32(114).fork()).join();
break;
case "bytes":
exports.BytesRules.encode(message.type.bytes, writer.uint32(122).fork()).join();
break;
case "enum":
exports.EnumRules.encode(message.type.enum, writer.uint32(130).fork()).join();
break;
case "repeated":
exports.RepeatedRules.encode(message.type.repeated, writer.uint32(146).fork()).join();
break;
case "map":
exports.MapRules.encode(message.type.map, writer.uint32(154).fork()).join();
break;
case "any":
exports.AnyRules.encode(message.type.any, writer.uint32(162).fork()).join();
break;
case "duration":
exports.DurationRules.encode(message.type.duration, writer.uint32(170).fork()).join();
break;
case "timestamp":
exports.TimestampRules.encode(message.type.timestamp, writer.uint32(178).fork()).join();
break;
}
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFieldRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 23: {
if (tag !== 186) {
break;
}
message.cel.push(exports.Rule.decode(reader, reader.uint32()));
continue;
}
case 25: {
if (tag !== 200) {
break;
}
message.required = reader.bool();
continue;
}
case 27: {
if (tag !== 216) {
break;
}
message.ignore = reader.int32();
continue;
}
case 1: {
if (tag !== 10) {
break;
}
message.type = {
$case: "float",
float: exports.FloatRules.decode(reader, reader.uint32()),
};
continue;
}
case 2: {
if (tag !== 18) {
break;
}
message.type = {
$case: "double",
double: exports.DoubleRules.decode(reader, reader.uint32()),
};
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.type = {
$case: "int32",
int32: exports.Int32Rules.decode(reader, reader.uint32()),
};
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.type = {
$case: "int64",
int64: exports.Int64Rules.decode(reader, reader.uint32()),
};
continue;
}
case 5: {
if (tag !== 42) {
break;
}
message.type = {
$case: "uint32",
uint32: exports.UInt32Rules.decode(reader, reader.uint32()),
};
continue;
}
case 6: {
if (tag !== 50) {
break;
}
message.type = {
$case: "uint64",
uint64: exports.UInt64Rules.decode(reader, reader.uint32()),
};
continue;
}
case 7: {
if (tag !== 58) {
break;
}
message.type = {
$case: "sint32",
sint32: exports.SInt32Rules.decode(reader, reader.uint32()),
};
continue;
}
case 8: {
if (tag !== 66) {
break;
}
message.type = {
$case: "sint64",
sint64: exports.SInt64Rules.decode(reader, reader.uint32()),
};
continue;
}
case 9: {
if (tag !== 74) {
break;
}
message.type = {
$case: "fixed32",
fixed32: exports.Fixed32Rules.decode(reader, reader.uint32()),
};
continue;
}
case 10: {
if (tag !== 82) {
break;
}
message.type = {
$case: "fixed64",
fixed64: exports.Fixed64Rules.decode(reader, reader.uint32()),
};
continue;
}
case 11: {
if (tag !== 90) {
break;
}
message.type = {
$case: "sfixed32",
sfixed32: exports.SFixed32Rules.decode(reader, reader.uint32()),
};
continue;
}
case 12: {
if (tag !== 98) {
break;
}
message.type = {
$case: "sfixed64",
sfixed64: exports.SFixed64Rules.decode(reader, reader.uint32()),
};
continue;
}
case 13: {
if (tag !== 106) {
break;
}
message.type = {
$case: "bool",
bool: exports.BoolRules.decode(reader, reader.uint32()),
};
continue;
}
case 14: {
if (tag !== 114) {
break;
}
message.type = {
$case: "string",
string: exports.StringRules.decode(reader, reader.uint32()),
};
continue;
}
case 15: {
if (tag !== 122) {
break;
}
message.type = {
$case: "bytes",
bytes: exports.BytesRules.decode(reader, reader.uint32()),
};
continue;
}
case 16: {
if (tag !== 130) {
break;
}
message.type = {
$case: "enum",
enum: exports.EnumRules.decode(reader, reader.uint32()),
};
continue;
}
case 18: {
if (tag !== 146) {
break;
}
message.type = {
$case: "repeated",
repeated: exports.RepeatedRules.decode(reader, reader.uint32()),
};
continue;
}
case 19: {
if (tag !== 154) {
break;
}
message.type = {
$case: "map",
map: exports.MapRules.decode(reader, reader.uint32()),
};
continue;
}
case 20: {
if (tag !== 162) {
break;
}
message.type = {
$case: "any",
any: exports.AnyRules.decode(reader, reader.uint32()),
};
continue;
}
case 21: {
if (tag !== 170) {
break;
}
message.type = {
$case: "duration",
duration: exports.DurationRules.decode(reader, reader.uint32()),
};
continue;
}
case 22: {
if (tag !== 178) {
break;
}
message.type = {
$case: "timestamp",
timestamp: exports.TimestampRules.decode(reader, reader.uint32()),
};
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBasePredefinedRules() {
return { cel: [] };
}
exports.PredefinedRules = {
encode(message, writer = new wire_1.BinaryWriter()) {
for (const v of message.cel) {
exports.Rule.encode(v, writer.uint32(10).fork()).join();
}
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBasePredefinedRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 10) {
break;
}
message.cel.push(exports.Rule.decode(reader, reader.uint32()));
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseFloatRules() {
return {
const: 0,
lessThan: undefined,
greaterThan: undefined,
in: [],
notIn: [],
finite: false,
example: [],
};
}
exports.FloatRules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(13).float(message.const);
}
switch (message.lessThan?.$case) {
case "lt":
writer.uint32(21).float(message.lessThan.lt);
break;
case "lte":
writer.uint32(29).float(message.lessThan.lte);
break;
}
switch (message.greaterThan?.$case) {
case "gt":
writer.uint32(37).float(message.greaterThan.gt);
break;
case "gte":
writer.uint32(45).float(message.greaterThan.gte);
break;
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.float(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.float(v);
}
writer.join();
if (message.finite !== undefined && message.finite !== false) {
writer.uint32(64).bool(message.finite);
}
writer.uint32(74).fork();
for (const v of message.example) {
writer.float(v);
}
writer.join();
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFloatRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 13) {
break;
}
message.const = reader.float();
continue;
}
case 2: {
if (tag !== 21) {
break;
}
message.lessThan = { $case: "lt", lt: reader.float() };
continue;
}
case 3: {
if (tag !== 29) {
break;
}
message.lessThan = { $case: "lte", lte: reader.float() };
continue;
}
case 4: {
if (tag !== 37) {
break;
}
message.greaterThan = { $case: "gt", gt: reader.float() };
continue;
}
case 5: {
if (tag !== 45) {
break;
}
message.greaterThan = { $case: "gte", gte: reader.float() };
continue;
}
case 6: {
if (tag === 53) {
message.in.push(reader.float());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.float());
}
continue;
}
break;
}
case 7: {
if (tag === 61) {
message.notIn.push(reader.float());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.float());
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.finite = reader.bool();
continue;
}
case 9: {
if (tag === 77) {
message.example.push(reader.float());
continue;
}
if (tag === 74) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.example.push(reader.float());
}
continue;
}
break;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseDoubleRules() {
return {
const: 0,
lessThan: undefined,
greaterThan: undefined,
in: [],
notIn: [],
finite: false,
example: [],
};
}
exports.DoubleRules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(9).double(message.const);
}
switch (message.lessThan?.$case) {
case "lt":
writer.uint32(17).double(message.lessThan.lt);
break;
case "lte":
writer.uint32(25).double(message.lessThan.lte);
break;
}
switch (message.greaterThan?.$case) {
case "gt":
writer.uint32(33).double(message.greaterThan.gt);
break;
case "gte":
writer.uint32(41).double(message.greaterThan.gte);
break;
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.double(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.double(v);
}
writer.join();
if (message.finite !== undefined && message.finite !== false) {
writer.uint32(64).bool(message.finite);
}
writer.uint32(74).fork();
for (const v of message.example) {
writer.double(v);
}
writer.join();
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseDoubleRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 9) {
break;
}
message.const = reader.double();
continue;
}
case 2: {
if (tag !== 17) {
break;
}
message.lessThan = { $case: "lt", lt: reader.double() };
continue;
}
case 3: {
if (tag !== 25) {
break;
}
message.lessThan = { $case: "lte", lte: reader.double() };
continue;
}
case 4: {
if (tag !== 33) {
break;
}
message.greaterThan = { $case: "gt", gt: reader.double() };
continue;
}
case 5: {
if (tag !== 41) {
break;
}
message.greaterThan = { $case: "gte", gte: reader.double() };
continue;
}
case 6: {
if (tag === 49) {
message.in.push(reader.double());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.double());
}
continue;
}
break;
}
case 7: {
if (tag === 57) {
message.notIn.push(reader.double());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.double());
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.finite = reader.bool();
continue;
}
case 9: {
if (tag === 73) {
message.example.push(reader.double());
continue;
}
if (tag === 74) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.example.push(reader.double());
}
continue;
}
break;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseInt32Rules() {
return {
const: 0,
lessThan: undefined,
greaterThan: undefined,
in: [],
notIn: [],
example: [],
};
}
exports.Int32Rules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(8).int32(message.const);
}
switch (message.lessThan?.$case) {
case "lt":
writer.uint32(16).int32(message.lessThan.lt);
break;
case "lte":
writer.uint32(24).int32(message.lessThan.lte);
break;
}
switch (message.greaterThan?.$case) {
case "gt":
writer.uint32(32).int32(message.greaterThan.gt);
break;
case "gte":
writer.uint32(40).int32(message.greaterThan.gte);
break;
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.int32(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.int32(v);
}
writer.join();
writer.uint32(66).fork();
for (const v of message.example) {
writer.int32(v);
}
writer.join();
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseInt32Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.const = reader.int32();
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lessThan = { $case: "lt", lt: reader.int32() };
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lessThan = { $case: "lte", lte: reader.int32() };
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.greaterThan = { $case: "gt", gt: reader.int32() };
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.greaterThan = { $case: "gte", gte: reader.int32() };
continue;
}
case 6: {
if (tag === 48) {
message.in.push(reader.int32());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.int32());
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(reader.int32());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.int32());
}
continue;
}
break;
}
case 8: {
if (tag === 64) {
message.example.push(reader.int32());
continue;
}
if (tag === 66) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.example.push(reader.int32());
}
continue;
}
break;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseInt64Rules() {
return {
const: "0",
lessThan: undefined,
greaterThan: undefined,
in: [],
notIn: [],
example: [],
};
}
exports.Int64Rules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.const !== undefined && message.const !== "0") {
writer.uint32(8).int64(message.const);
}
switch (message.lessThan?.$case) {
case "lt":
writer.uint32(16).int64(message.lessThan.lt);
break;
case "lte":
writer.uint32(24).int64(message.lessThan.lte);
break;
}
switch (message.greaterThan?.$case) {
case "gt":
writer.uint32(32).int64(message.greaterThan.gt);
break;
case "gte":
writer.uint32(40).int64(message.greaterThan.gte);
break;
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.int64(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.int64(v);
}
writer.join();
writer.uint32(74).fork();
for (const v of message.example) {
writer.int64(v);
}
writer.join();
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseInt64Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.const = reader.int64().toString();
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lessThan = { $case: "lt", lt: reader.int64().toString() };
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lessThan = { $case: "lte", lte: reader.int64().toString() };
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.greaterThan = { $case: "gt", gt: reader.int64().toString() };
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.greaterThan = {
$case: "gte",
gte: reader.int64().toString(),
};
continue;
}
case 6: {
if (tag === 48) {
message.in.push(reader.int64().toString());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.int64().toString());
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(reader.int64().toString());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.int64().toString());
}
continue;
}
break;
}
case 9: {
if (tag === 72) {
message.example.push(reader.int64().toString());
continue;
}
if (tag === 74) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.example.push(reader.int64().toString());
}
continue;
}
break;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseUInt32Rules() {
return {
const: 0,
lessThan: undefined,
greaterThan: undefined,
in: [],
notIn: [],
example: [],
};
}
exports.UInt32Rules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(8).uint32(message.const);
}
switch (message.lessThan?.$case) {
case "lt":
writer.uint32(16).uint32(message.lessThan.lt);
break;
case "lte":
writer.uint32(24).uint32(message.lessThan.lte);
break;
}
switch (message.greaterThan?.$case) {
case "gt":
writer.uint32(32).uint32(message.greaterThan.gt);
break;
case "gte":
writer.uint32(40).uint32(message.greaterThan.gte);
break;
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.uint32(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.uint32(v);
}
writer.join();
writer.uint32(66).fork();
for (const v of message.example) {
writer.uint32(v);
}
writer.join();
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseUInt32Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.const = reader.uint32();
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lessThan = { $case: "lt", lt: reader.uint32() };
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lessThan = { $case: "lte", lte: reader.uint32() };
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.greaterThan = { $case: "gt", gt: reader.uint32() };
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.greaterThan = { $case: "gte", gte: reader.uint32() };
continue;
}
case 6: {
if (tag === 48) {
message.in.push(reader.uint32());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.uint32());
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(reader.uint32());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.uint32());
}
continue;
}
break;
}
case 8: {
if (tag === 64) {
message.example.push(reader.uint32());
continue;
}
if (tag === 66) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.example.push(reader.uint32());
}
continue;
}
break;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseUInt64Rules() {
return {
const: "0",
lessThan: undefined,
greaterThan: undefined,
in: [],
notIn: [],
example: [],
};
}
exports.UInt64Rules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.const !== undefined && message.const !== "0") {
writer.uint32(8).uint64(message.const);
}
switch (message.lessThan?.$case) {
case "lt":
writer.uint32(16).uint64(message.lessThan.lt);
break;
case "lte":
writer.uint32(24).uint64(message.lessThan.lte);
break;
}
switch (message.greaterThan?.$case) {
case "gt":
writer.uint32(32).uint64(message.greaterThan.gt);
break;
case "gte":
writer.uint32(40).uint64(message.greaterThan.gte);
break;
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.uint64(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.uint64(v);
}
writer.join();
writer.uint32(66).fork();
for (const v of message.example) {
writer.uint64(v);
}
writer.join();
return writer;
},
decode(input, length) {
const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseUInt64Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.const = reader.uint64().toString();
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lessThan = { $case: "lt", lt: reader.uint64().toString() };
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lessThan = { $case: "lte", lte: reader.uint64().toString() };
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.greaterThan = { $case: "gt", gt: reader.uint64().toString() };
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.greaterThan = {
$case: "gte",
gte: reader.uint64().toString(),
};
continue;
}
case 6: {
if (tag === 48) {
message.in.push(reader.uint64().toString());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.uint64().toString());
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(reader.uint64().toString());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.uint64().toString());
}
continue;
}
break;
}
case 8: {
if (tag === 64) {
message.example.push(reader.uint64().toString());
continue;
}
if (tag === 66) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.example.push(reader.uint64().toString());
}
continue;
}
break;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
};
function createBaseSInt32Rules() {
return {
const: 0,
lessThan: undefined,
greaterThan: undefined,
in: [],
notIn: [],
example: [],
};
}
exports.SInt32Rules = {
encode(message, writer = new wire_1.BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(8).sint32(message.const);
}
switch (message.lessThan?.$case) {
case "lt":
writer.uint32(16).sint32(message.lessThan.lt);
break;
case "lte":
writer.uint32(24).sint32(message.lessThan.lte);
break;
}
switch (message.greaterThan?.$case) {
case "gt":
writer.uint32(32).sint32(message.greaterThan.gt);
break;
case "gte":
writer.uint32(40).sint32(message.greaterThan.gte);
break;
}
writer.uint32(5