@zitadel/node
Version:
Library for API access to ZITADEL. Provides compiled gRPC service clients and helpers for applications and service accounts.
4,337 lines • 167 kB
JavaScript
// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
// protoc-gen-ts_proto v2.7.5
// protoc unknown
// source: validate/validate.proto
/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import Long from "long";
import { Duration } from "../google/protobuf/duration.js";
import { Timestamp } from "../google/protobuf/timestamp.js";
export const protobufPackage = "validate";
/** WellKnownRegex contain some well-known patterns. */
export var KnownRegex;
(function (KnownRegex) {
KnownRegex[KnownRegex["UNKNOWN"] = 0] = "UNKNOWN";
/** HTTP_HEADER_NAME - HTTP header name as defined by RFC 7230. */
KnownRegex[KnownRegex["HTTP_HEADER_NAME"] = 1] = "HTTP_HEADER_NAME";
/** HTTP_HEADER_VALUE - HTTP header value as defined by RFC 7230. */
KnownRegex[KnownRegex["HTTP_HEADER_VALUE"] = 2] = "HTTP_HEADER_VALUE";
KnownRegex[KnownRegex["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
})(KnownRegex || (KnownRegex = {}));
export function knownRegexFromJSON(object) {
switch (object) {
case 0:
case "UNKNOWN":
return KnownRegex.UNKNOWN;
case 1:
case "HTTP_HEADER_NAME":
return KnownRegex.HTTP_HEADER_NAME;
case 2:
case "HTTP_HEADER_VALUE":
return KnownRegex.HTTP_HEADER_VALUE;
case -1:
case "UNRECOGNIZED":
default:
return KnownRegex.UNRECOGNIZED;
}
}
export function knownRegexToJSON(object) {
switch (object) {
case KnownRegex.UNKNOWN:
return "UNKNOWN";
case KnownRegex.HTTP_HEADER_NAME:
return "HTTP_HEADER_NAME";
case KnownRegex.HTTP_HEADER_VALUE:
return "HTTP_HEADER_VALUE";
case KnownRegex.UNRECOGNIZED:
default:
return "UNRECOGNIZED";
}
}
function createBaseFieldRules() {
return {
message: undefined,
float: undefined,
double: undefined,
int32: undefined,
int64: undefined,
uint32: undefined,
uint64: undefined,
sint32: undefined,
sint64: undefined,
fixed32: undefined,
fixed64: undefined,
sfixed32: undefined,
sfixed64: undefined,
bool: undefined,
string: undefined,
bytes: undefined,
enum: undefined,
repeated: undefined,
map: undefined,
any: undefined,
duration: undefined,
timestamp: undefined,
};
}
export const FieldRules = {
encode(message, writer = new BinaryWriter()) {
if (message.message !== undefined) {
MessageRules.encode(message.message, writer.uint32(138).fork()).join();
}
if (message.float !== undefined) {
FloatRules.encode(message.float, writer.uint32(10).fork()).join();
}
if (message.double !== undefined) {
DoubleRules.encode(message.double, writer.uint32(18).fork()).join();
}
if (message.int32 !== undefined) {
Int32Rules.encode(message.int32, writer.uint32(26).fork()).join();
}
if (message.int64 !== undefined) {
Int64Rules.encode(message.int64, writer.uint32(34).fork()).join();
}
if (message.uint32 !== undefined) {
UInt32Rules.encode(message.uint32, writer.uint32(42).fork()).join();
}
if (message.uint64 !== undefined) {
UInt64Rules.encode(message.uint64, writer.uint32(50).fork()).join();
}
if (message.sint32 !== undefined) {
SInt32Rules.encode(message.sint32, writer.uint32(58).fork()).join();
}
if (message.sint64 !== undefined) {
SInt64Rules.encode(message.sint64, writer.uint32(66).fork()).join();
}
if (message.fixed32 !== undefined) {
Fixed32Rules.encode(message.fixed32, writer.uint32(74).fork()).join();
}
if (message.fixed64 !== undefined) {
Fixed64Rules.encode(message.fixed64, writer.uint32(82).fork()).join();
}
if (message.sfixed32 !== undefined) {
SFixed32Rules.encode(message.sfixed32, writer.uint32(90).fork()).join();
}
if (message.sfixed64 !== undefined) {
SFixed64Rules.encode(message.sfixed64, writer.uint32(98).fork()).join();
}
if (message.bool !== undefined) {
BoolRules.encode(message.bool, writer.uint32(106).fork()).join();
}
if (message.string !== undefined) {
StringRules.encode(message.string, writer.uint32(114).fork()).join();
}
if (message.bytes !== undefined) {
BytesRules.encode(message.bytes, writer.uint32(122).fork()).join();
}
if (message.enum !== undefined) {
EnumRules.encode(message.enum, writer.uint32(130).fork()).join();
}
if (message.repeated !== undefined) {
RepeatedRules.encode(message.repeated, writer.uint32(146).fork()).join();
}
if (message.map !== undefined) {
MapRules.encode(message.map, writer.uint32(154).fork()).join();
}
if (message.any !== undefined) {
AnyRules.encode(message.any, writer.uint32(162).fork()).join();
}
if (message.duration !== undefined) {
DurationRules.encode(message.duration, writer.uint32(170).fork()).join();
}
if (message.timestamp !== undefined) {
TimestampRules.encode(message.timestamp, writer.uint32(178).fork()).join();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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 17: {
if (tag !== 138) {
break;
}
message.message = MessageRules.decode(reader, reader.uint32());
continue;
}
case 1: {
if (tag !== 10) {
break;
}
message.float = FloatRules.decode(reader, reader.uint32());
continue;
}
case 2: {
if (tag !== 18) {
break;
}
message.double = DoubleRules.decode(reader, reader.uint32());
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.int32 = Int32Rules.decode(reader, reader.uint32());
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.int64 = Int64Rules.decode(reader, reader.uint32());
continue;
}
case 5: {
if (tag !== 42) {
break;
}
message.uint32 = UInt32Rules.decode(reader, reader.uint32());
continue;
}
case 6: {
if (tag !== 50) {
break;
}
message.uint64 = UInt64Rules.decode(reader, reader.uint32());
continue;
}
case 7: {
if (tag !== 58) {
break;
}
message.sint32 = SInt32Rules.decode(reader, reader.uint32());
continue;
}
case 8: {
if (tag !== 66) {
break;
}
message.sint64 = SInt64Rules.decode(reader, reader.uint32());
continue;
}
case 9: {
if (tag !== 74) {
break;
}
message.fixed32 = Fixed32Rules.decode(reader, reader.uint32());
continue;
}
case 10: {
if (tag !== 82) {
break;
}
message.fixed64 = Fixed64Rules.decode(reader, reader.uint32());
continue;
}
case 11: {
if (tag !== 90) {
break;
}
message.sfixed32 = SFixed32Rules.decode(reader, reader.uint32());
continue;
}
case 12: {
if (tag !== 98) {
break;
}
message.sfixed64 = SFixed64Rules.decode(reader, reader.uint32());
continue;
}
case 13: {
if (tag !== 106) {
break;
}
message.bool = BoolRules.decode(reader, reader.uint32());
continue;
}
case 14: {
if (tag !== 114) {
break;
}
message.string = StringRules.decode(reader, reader.uint32());
continue;
}
case 15: {
if (tag !== 122) {
break;
}
message.bytes = BytesRules.decode(reader, reader.uint32());
continue;
}
case 16: {
if (tag !== 130) {
break;
}
message.enum = EnumRules.decode(reader, reader.uint32());
continue;
}
case 18: {
if (tag !== 146) {
break;
}
message.repeated = RepeatedRules.decode(reader, reader.uint32());
continue;
}
case 19: {
if (tag !== 154) {
break;
}
message.map = MapRules.decode(reader, reader.uint32());
continue;
}
case 20: {
if (tag !== 162) {
break;
}
message.any = AnyRules.decode(reader, reader.uint32());
continue;
}
case 21: {
if (tag !== 170) {
break;
}
message.duration = DurationRules.decode(reader, reader.uint32());
continue;
}
case 22: {
if (tag !== 178) {
break;
}
message.timestamp = TimestampRules.decode(reader, reader.uint32());
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
message: isSet(object.message) ? MessageRules.fromJSON(object.message) : undefined,
float: isSet(object.float) ? FloatRules.fromJSON(object.float) : undefined,
double: isSet(object.double) ? DoubleRules.fromJSON(object.double) : undefined,
int32: isSet(object.int32) ? Int32Rules.fromJSON(object.int32) : undefined,
int64: isSet(object.int64) ? Int64Rules.fromJSON(object.int64) : undefined,
uint32: isSet(object.uint32) ? UInt32Rules.fromJSON(object.uint32) : undefined,
uint64: isSet(object.uint64) ? UInt64Rules.fromJSON(object.uint64) : undefined,
sint32: isSet(object.sint32) ? SInt32Rules.fromJSON(object.sint32) : undefined,
sint64: isSet(object.sint64) ? SInt64Rules.fromJSON(object.sint64) : undefined,
fixed32: isSet(object.fixed32) ? Fixed32Rules.fromJSON(object.fixed32) : undefined,
fixed64: isSet(object.fixed64) ? Fixed64Rules.fromJSON(object.fixed64) : undefined,
sfixed32: isSet(object.sfixed32) ? SFixed32Rules.fromJSON(object.sfixed32) : undefined,
sfixed64: isSet(object.sfixed64) ? SFixed64Rules.fromJSON(object.sfixed64) : undefined,
bool: isSet(object.bool) ? BoolRules.fromJSON(object.bool) : undefined,
string: isSet(object.string) ? StringRules.fromJSON(object.string) : undefined,
bytes: isSet(object.bytes) ? BytesRules.fromJSON(object.bytes) : undefined,
enum: isSet(object.enum) ? EnumRules.fromJSON(object.enum) : undefined,
repeated: isSet(object.repeated) ? RepeatedRules.fromJSON(object.repeated) : undefined,
map: isSet(object.map) ? MapRules.fromJSON(object.map) : undefined,
any: isSet(object.any) ? AnyRules.fromJSON(object.any) : undefined,
duration: isSet(object.duration) ? DurationRules.fromJSON(object.duration) : undefined,
timestamp: isSet(object.timestamp) ? TimestampRules.fromJSON(object.timestamp) : undefined,
};
},
toJSON(message) {
const obj = {};
if (message.message !== undefined) {
obj.message = MessageRules.toJSON(message.message);
}
if (message.float !== undefined) {
obj.float = FloatRules.toJSON(message.float);
}
if (message.double !== undefined) {
obj.double = DoubleRules.toJSON(message.double);
}
if (message.int32 !== undefined) {
obj.int32 = Int32Rules.toJSON(message.int32);
}
if (message.int64 !== undefined) {
obj.int64 = Int64Rules.toJSON(message.int64);
}
if (message.uint32 !== undefined) {
obj.uint32 = UInt32Rules.toJSON(message.uint32);
}
if (message.uint64 !== undefined) {
obj.uint64 = UInt64Rules.toJSON(message.uint64);
}
if (message.sint32 !== undefined) {
obj.sint32 = SInt32Rules.toJSON(message.sint32);
}
if (message.sint64 !== undefined) {
obj.sint64 = SInt64Rules.toJSON(message.sint64);
}
if (message.fixed32 !== undefined) {
obj.fixed32 = Fixed32Rules.toJSON(message.fixed32);
}
if (message.fixed64 !== undefined) {
obj.fixed64 = Fixed64Rules.toJSON(message.fixed64);
}
if (message.sfixed32 !== undefined) {
obj.sfixed32 = SFixed32Rules.toJSON(message.sfixed32);
}
if (message.sfixed64 !== undefined) {
obj.sfixed64 = SFixed64Rules.toJSON(message.sfixed64);
}
if (message.bool !== undefined) {
obj.bool = BoolRules.toJSON(message.bool);
}
if (message.string !== undefined) {
obj.string = StringRules.toJSON(message.string);
}
if (message.bytes !== undefined) {
obj.bytes = BytesRules.toJSON(message.bytes);
}
if (message.enum !== undefined) {
obj.enum = EnumRules.toJSON(message.enum);
}
if (message.repeated !== undefined) {
obj.repeated = RepeatedRules.toJSON(message.repeated);
}
if (message.map !== undefined) {
obj.map = MapRules.toJSON(message.map);
}
if (message.any !== undefined) {
obj.any = AnyRules.toJSON(message.any);
}
if (message.duration !== undefined) {
obj.duration = DurationRules.toJSON(message.duration);
}
if (message.timestamp !== undefined) {
obj.timestamp = TimestampRules.toJSON(message.timestamp);
}
return obj;
},
create(base) {
return FieldRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseFieldRules();
message.message = (object.message !== undefined && object.message !== null)
? MessageRules.fromPartial(object.message)
: undefined;
message.float = (object.float !== undefined && object.float !== null)
? FloatRules.fromPartial(object.float)
: undefined;
message.double = (object.double !== undefined && object.double !== null)
? DoubleRules.fromPartial(object.double)
: undefined;
message.int32 = (object.int32 !== undefined && object.int32 !== null)
? Int32Rules.fromPartial(object.int32)
: undefined;
message.int64 = (object.int64 !== undefined && object.int64 !== null)
? Int64Rules.fromPartial(object.int64)
: undefined;
message.uint32 = (object.uint32 !== undefined && object.uint32 !== null)
? UInt32Rules.fromPartial(object.uint32)
: undefined;
message.uint64 = (object.uint64 !== undefined && object.uint64 !== null)
? UInt64Rules.fromPartial(object.uint64)
: undefined;
message.sint32 = (object.sint32 !== undefined && object.sint32 !== null)
? SInt32Rules.fromPartial(object.sint32)
: undefined;
message.sint64 = (object.sint64 !== undefined && object.sint64 !== null)
? SInt64Rules.fromPartial(object.sint64)
: undefined;
message.fixed32 = (object.fixed32 !== undefined && object.fixed32 !== null)
? Fixed32Rules.fromPartial(object.fixed32)
: undefined;
message.fixed64 = (object.fixed64 !== undefined && object.fixed64 !== null)
? Fixed64Rules.fromPartial(object.fixed64)
: undefined;
message.sfixed32 = (object.sfixed32 !== undefined && object.sfixed32 !== null)
? SFixed32Rules.fromPartial(object.sfixed32)
: undefined;
message.sfixed64 = (object.sfixed64 !== undefined && object.sfixed64 !== null)
? SFixed64Rules.fromPartial(object.sfixed64)
: undefined;
message.bool = (object.bool !== undefined && object.bool !== null) ? BoolRules.fromPartial(object.bool) : undefined;
message.string = (object.string !== undefined && object.string !== null)
? StringRules.fromPartial(object.string)
: undefined;
message.bytes = (object.bytes !== undefined && object.bytes !== null)
? BytesRules.fromPartial(object.bytes)
: undefined;
message.enum = (object.enum !== undefined && object.enum !== null) ? EnumRules.fromPartial(object.enum) : undefined;
message.repeated = (object.repeated !== undefined && object.repeated !== null)
? RepeatedRules.fromPartial(object.repeated)
: undefined;
message.map = (object.map !== undefined && object.map !== null) ? MapRules.fromPartial(object.map) : undefined;
message.any = (object.any !== undefined && object.any !== null) ? AnyRules.fromPartial(object.any) : undefined;
message.duration = (object.duration !== undefined && object.duration !== null)
? DurationRules.fromPartial(object.duration)
: undefined;
message.timestamp = (object.timestamp !== undefined && object.timestamp !== null)
? TimestampRules.fromPartial(object.timestamp)
: undefined;
return message;
},
};
function createBaseFloatRules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
export const FloatRules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(13).float(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
writer.uint32(21).float(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
writer.uint32(29).float(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
writer.uint32(37).float(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
writer.uint32(45).float(message.gte);
}
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.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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.lt = reader.float();
continue;
}
case 3: {
if (tag !== 29) {
break;
}
message.lte = reader.float();
continue;
}
case 4: {
if (tag !== 37) {
break;
}
message.gt = reader.float();
continue;
}
case 5: {
if (tag !== 45) {
break;
}
message.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.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
lt: isSet(object.lt) ? globalThis.Number(object.lt) : 0,
lte: isSet(object.lte) ? globalThis.Number(object.lte) : 0,
gt: isSet(object.gt) ? globalThis.Number(object.gt) : 0,
gte: isSet(object.gte) ? globalThis.Number(object.gte) : 0,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = message.const;
}
if (message.lt !== undefined && message.lt !== 0) {
obj.lt = message.lt;
}
if (message.lte !== undefined && message.lte !== 0) {
obj.lte = message.lte;
}
if (message.gt !== undefined && message.gt !== 0) {
obj.gt = message.gt;
}
if (message.gte !== undefined && message.gte !== 0) {
obj.gte = message.gte;
}
if (message.in?.length) {
obj.in = message.in;
}
if (message.notIn?.length) {
obj.notIn = message.notIn;
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return FloatRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseFloatRules();
message.const = object.const ?? 0;
message.lt = object.lt ?? 0;
message.lte = object.lte ?? 0;
message.gt = object.gt ?? 0;
message.gte = object.gte ?? 0;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseDoubleRules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
export const DoubleRules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(9).double(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
writer.uint32(17).double(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
writer.uint32(25).double(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
writer.uint32(33).double(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
writer.uint32(41).double(message.gte);
}
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.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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.lt = reader.double();
continue;
}
case 3: {
if (tag !== 25) {
break;
}
message.lte = reader.double();
continue;
}
case 4: {
if (tag !== 33) {
break;
}
message.gt = reader.double();
continue;
}
case 5: {
if (tag !== 41) {
break;
}
message.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.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
lt: isSet(object.lt) ? globalThis.Number(object.lt) : 0,
lte: isSet(object.lte) ? globalThis.Number(object.lte) : 0,
gt: isSet(object.gt) ? globalThis.Number(object.gt) : 0,
gte: isSet(object.gte) ? globalThis.Number(object.gte) : 0,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = message.const;
}
if (message.lt !== undefined && message.lt !== 0) {
obj.lt = message.lt;
}
if (message.lte !== undefined && message.lte !== 0) {
obj.lte = message.lte;
}
if (message.gt !== undefined && message.gt !== 0) {
obj.gt = message.gt;
}
if (message.gte !== undefined && message.gte !== 0) {
obj.gte = message.gte;
}
if (message.in?.length) {
obj.in = message.in;
}
if (message.notIn?.length) {
obj.notIn = message.notIn;
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return DoubleRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseDoubleRules();
message.const = object.const ?? 0;
message.lt = object.lt ?? 0;
message.lte = object.lte ?? 0;
message.gt = object.gt ?? 0;
message.gte = object.gte ?? 0;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseInt32Rules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
export const Int32Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(8).int32(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
writer.uint32(16).int32(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
writer.uint32(24).int32(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
writer.uint32(32).int32(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
writer.uint32(40).int32(message.gte);
}
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();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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.lt = reader.int32();
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = reader.int32();
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = reader.int32();
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.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) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
lt: isSet(object.lt) ? globalThis.Number(object.lt) : 0,
lte: isSet(object.lte) ? globalThis.Number(object.lte) : 0,
gt: isSet(object.gt) ? globalThis.Number(object.gt) : 0,
gte: isSet(object.gte) ? globalThis.Number(object.gte) : 0,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
obj.lt = Math.round(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
obj.lte = Math.round(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
obj.gt = Math.round(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
obj.gte = Math.round(message.gte);
}
if (message.in?.length) {
obj.in = message.in.map((e) => Math.round(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => Math.round(e));
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return Int32Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseInt32Rules();
message.const = object.const ?? 0;
message.lt = object.lt ?? 0;
message.lte = object.lte ?? 0;
message.gt = object.gt ?? 0;
message.gte = object.gte ?? 0;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseInt64Rules() {
return {
const: Long.ZERO,
lt: Long.ZERO,
lte: Long.ZERO,
gt: Long.ZERO,
gte: Long.ZERO,
in: [],
notIn: [],
ignoreEmpty: false,
};
}
export const Int64Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
writer.uint32(8).int64(message.const.toString());
}
if (message.lt !== undefined && !message.lt.equals(Long.ZERO)) {
writer.uint32(16).int64(message.lt.toString());
}
if (message.lte !== undefined && !message.lte.equals(Long.ZERO)) {
writer.uint32(24).int64(message.lte.toString());
}
if (message.gt !== undefined && !message.gt.equals(Long.ZERO)) {
writer.uint32(32).int64(message.gt.toString());
}
if (message.gte !== undefined && !message.gte.equals(Long.ZERO)) {
writer.uint32(40).int64(message.gte.toString());
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.int64(v.toString());
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.int64(v.toString());
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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 = Long.fromString(reader.int64().toString());
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lt = Long.fromString(reader.int64().toString());
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = Long.fromString(reader.int64().toString());
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = Long.fromString(reader.int64().toString());
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.gte = Long.fromString(reader.int64().toString());
continue;
}
case 6: {
if (tag === 48) {
message.in.push(Long.fromString(reader.int64().toString()));
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(Long.fromString(reader.int64().toString()));
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(Long.fromString(reader.int64().toString()));
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(Long.fromString(reader.int64().toString()));
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? Long.fromValue(object.const) : Long.ZERO,
lt: isSet(object.lt) ? Long.fromValue(object.lt) : Long.ZERO,
lte: isSet(object.lte) ? Long.fromValue(object.lte) : Long.ZERO,
gt: isSet(object.gt) ? Long.fromValue(object.gt) : Long.ZERO,
gte: isSet(object.gte) ? Long.fromValue(object.gte) : Long.ZERO,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => Long.fromValue(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => Long.fromValue(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
obj.const = (message.const || Long.ZERO).toString();
}
if (message.lt !== undefined && !message.lt.equals(Long.ZERO)) {
obj.lt = (message.lt || Long.ZERO).toString();
}
if (message.lte !== undefined && !message.lte.equals(Long.ZERO)) {
obj.lte = (message.lte || Long.ZERO).toString();
}
if (message.gt !== undefined && !message.gt.equals(Long.ZERO)) {
obj.gt = (message.gt || Long.ZERO).toString();
}
if (message.gte !== undefined && !message.gte.equals(Long.ZERO)) {
obj.gte = (message.gte || Long.ZERO).toString();
}
if (message.in?.length) {
obj.in = message.in.map((e) => (e || Long.ZERO).toString());
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => (e || Long.ZERO).toString());
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return Int64Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseInt64Rules();
message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.ZERO;
message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : Long.ZERO;
message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : Long.ZERO;
message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : Long.ZERO;
message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : Long.ZERO;
message.in = object.in?.map((e) => Long.fromValue(e)) || [];
message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseUInt32Rules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
export const UInt32Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(8).uint32(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
writer.uint32(16).uint32(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
writer.uint32(24).uint32(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
writer.uint32(32).uint32(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
writer.uint32(40).uint32(message.gte);
}
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();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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.lt = reader.uint32();
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = reader.uint32();
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = reader.uint32();
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.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) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
lt: isSet(object.lt) ? globalThis.Number(object.lt) : 0,
lte: isSet(object.lte) ? globalThis.Number(object.lte) : 0,
gt: isSet(object.gt) ? globalThis.Number(object.gt) : 0,
gte: isSet(object.gte) ? globalThis.Number(object.gte) : 0,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
obj.lt = Math.round(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
obj.lte = Math.round(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
obj.gt = Math.round(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
obj.gte = Math.round(message.gte);
}
if (message.in?.length) {
obj.in = message.in.map((e) => Math.round(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => Math.round(e));
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return UInt32Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseUInt32Rules();
message.const = object.const ?? 0;
message.lt = object.lt ?? 0;
message.lte = object.lte ?? 0;
message.gt = object.gt ?? 0;
message.gte = object.gte ?? 0;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseUInt64Rules() {
return {
const: Long.UZERO,
lt: Long.UZERO,
lte: Long.UZERO,
gt: Long.UZERO,
gte: Long.UZERO,
in: [],
notIn: [],
ignoreEmpty: false,
};
}
export const UInt64Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && !message.const.equals(Long.UZERO)) {
writer.uint32(8).uint64(message.const.toString());
}
if (message.lt !== undefined && !message.lt.equals(Long.UZERO)) {
writer.uint32(16).uint64(message.lt.toString());
}
if (message.lte !== undefined && !message.lte.equals(Long.UZERO)) {
writer.uint32(24).uint64(message.lte.toString());
}
if (message.gt !== undefined && !message.gt.equals(Long.UZERO)) {
writer.uint32(32).uint64(message.gt.toString());
}
if (message.gte !== undefined && !message.gte.equals(Long.UZERO)) {
writer.uint32(40).uint64(message.gte.toString());
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.uint64(v.toString());
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.uint64(v.toString());
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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 = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lt = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.gte = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 6: {
if (tag === 48) {
message.in.push(Long.fromString(reader.uint64().toString(), true));
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(Long.fromString(reader.uint64().toString(), true));
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(Long.fromString(reader.uint64().toString(), true));
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(Long.fromString(reader.uint64().toString(), true));
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? Long.fromValue(object.const) : Long.UZERO,
lt: isSet(object.lt) ? Long.fromValue(object.lt) : Long.UZERO,
lte: isSet(object.lte) ? Long.fromValue(object.lte) : Long.UZERO,
gt: isSet(object.gt) ? Long.fromValue(object.gt) : Long.UZERO,
gte: isSet(object.gte) ? Long.fromValue(object.gte) : Long.UZERO,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => Long.fromValue(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => Long.fromValue(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && !message.const.equals(Long.UZERO)) {
obj.const = (message.const || Long.UZERO).toString();
}
if (message.lt !== undefined && !message.lt.equals(Long.UZERO)) {
obj.lt = (message.lt || Long.UZERO).toString();
}
if (message.lte !== undefined && !message.lte.equals(Long.UZERO)) {
obj.lte = (message.lte || Long.UZERO).toString();
}
if (message.gt !== undefined && !message.gt.equals(Long.UZERO)) {
obj.gt = (message.gt || Long.UZERO).toString();
}
if (message.gte !== undefined && !message.gte.equals(Long.UZERO)) {
obj.gte = (message.gte || Long.UZERO).toString();
}
if (message.in?.length) {
obj.in = message.in.map((e) => (e || Long.UZERO).toString());
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => (e || Long.UZERO).toString());
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return UInt64Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseUInt64Rules();
message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.UZERO;
message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : Long.UZERO;
message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : Long.UZERO;
message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : Long.UZERO;
message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : Long.UZERO;
message.in = object.in?.map((e) => Long.fromValue(e)) || [];
message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseSInt32Rules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
export const SInt32Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(8).sint32(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
writer.uint32(16).sint32(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
writer.uint32(24).sint32(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
writer.uint32(32).sint32(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
writer.uint32(40).sint32(message.gte);
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.sint32(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.sint32(v);
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseSInt32Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.const = reader.sint32();
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lt = reader.sint32();
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = reader.sint32();
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = reader.sint32();
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.gte = reader.sint32();
continue;
}
case 6: {
if (tag === 48) {
message.in.push(reader.sint32());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.sint32());
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(reader.sint32());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.sint32());
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
lt: isSet(object.lt) ? globalThis.Number(object.lt) : 0,
lte: isSet(object.lte) ? globalThis.Number(object.lte) : 0,
gt: isSet(object.gt) ? globalThis.Number(object.gt) : 0,
gte: isSet(object.gte) ? globalThis.Number(object.gte) : 0,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
obj.lt = Math.round(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
obj.lte = Math.round(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
obj.gt = Math.round(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
obj.gte = Math.round(message.gte);
}
if (message.in?.length) {
obj.in = message.in.map((e) => Math.round(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => Math.round(e));
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return SInt32Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseSInt32Rules();
message.const = object.const ?? 0;
message.lt = object.lt ?? 0;
message.lte = object.lte ?? 0;
message.gt = object.gt ?? 0;
message.gte = object.gte ?? 0;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseSInt64Rules() {
return {
const: Long.ZERO,
lt: Long.ZERO,
lte: Long.ZERO,
gt: Long.ZERO,
gte: Long.ZERO,
in: [],
notIn: [],
ignoreEmpty: false,
};
}
export const SInt64Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
writer.uint32(8).sint64(message.const.toString());
}
if (message.lt !== undefined && !message.lt.equals(Long.ZERO)) {
writer.uint32(16).sint64(message.lt.toString());
}
if (message.lte !== undefined && !message.lte.equals(Long.ZERO)) {
writer.uint32(24).sint64(message.lte.toString());
}
if (message.gt !== undefined && !message.gt.equals(Long.ZERO)) {
writer.uint32(32).sint64(message.gt.toString());
}
if (message.gte !== undefined && !message.gte.equals(Long.ZERO)) {
writer.uint32(40).sint64(message.gte.toString());
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.sint64(v.toString());
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.sint64(v.toString());
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseSInt64Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.const = Long.fromString(reader.sint64().toString());
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lt = Long.fromString(reader.sint64().toString());
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = Long.fromString(reader.sint64().toString());
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = Long.fromString(reader.sint64().toString());
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.gte = Long.fromString(reader.sint64().toString());
continue;
}
case 6: {
if (tag === 48) {
message.in.push(Long.fromString(reader.sint64().toString()));
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(Long.fromString(reader.sint64().toString()));
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(Long.fromString(reader.sint64().toString()));
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(Long.fromString(reader.sint64().toString()));
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? Long.fromValue(object.const) : Long.ZERO,
lt: isSet(object.lt) ? Long.fromValue(object.lt) : Long.ZERO,
lte: isSet(object.lte) ? Long.fromValue(object.lte) : Long.ZERO,
gt: isSet(object.gt) ? Long.fromValue(object.gt) : Long.ZERO,
gte: isSet(object.gte) ? Long.fromValue(object.gte) : Long.ZERO,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => Long.fromValue(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => Long.fromValue(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
obj.const = (message.const || Long.ZERO).toString();
}
if (message.lt !== undefined && !message.lt.equals(Long.ZERO)) {
obj.lt = (message.lt || Long.ZERO).toString();
}
if (message.lte !== undefined && !message.lte.equals(Long.ZERO)) {
obj.lte = (message.lte || Long.ZERO).toString();
}
if (message.gt !== undefined && !message.gt.equals(Long.ZERO)) {
obj.gt = (message.gt || Long.ZERO).toString();
}
if (message.gte !== undefined && !message.gte.equals(Long.ZERO)) {
obj.gte = (message.gte || Long.ZERO).toString();
}
if (message.in?.length) {
obj.in = message.in.map((e) => (e || Long.ZERO).toString());
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => (e || Long.ZERO).toString());
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return SInt64Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseSInt64Rules();
message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.ZERO;
message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : Long.ZERO;
message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : Long.ZERO;
message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : Long.ZERO;
message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : Long.ZERO;
message.in = object.in?.map((e) => Long.fromValue(e)) || [];
message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseFixed32Rules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
export const Fixed32Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(13).fixed32(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
writer.uint32(21).fixed32(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
writer.uint32(29).fixed32(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
writer.uint32(37).fixed32(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
writer.uint32(45).fixed32(message.gte);
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.fixed32(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.fixed32(v);
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFixed32Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 13) {
break;
}
message.const = reader.fixed32();
continue;
}
case 2: {
if (tag !== 21) {
break;
}
message.lt = reader.fixed32();
continue;
}
case 3: {
if (tag !== 29) {
break;
}
message.lte = reader.fixed32();
continue;
}
case 4: {
if (tag !== 37) {
break;
}
message.gt = reader.fixed32();
continue;
}
case 5: {
if (tag !== 45) {
break;
}
message.gte = reader.fixed32();
continue;
}
case 6: {
if (tag === 53) {
message.in.push(reader.fixed32());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.fixed32());
}
continue;
}
break;
}
case 7: {
if (tag === 61) {
message.notIn.push(reader.fixed32());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.fixed32());
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
lt: isSet(object.lt) ? globalThis.Number(object.lt) : 0,
lte: isSet(object.lte) ? globalThis.Number(object.lte) : 0,
gt: isSet(object.gt) ? globalThis.Number(object.gt) : 0,
gte: isSet(object.gte) ? globalThis.Number(object.gte) : 0,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
obj.lt = Math.round(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
obj.lte = Math.round(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
obj.gt = Math.round(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
obj.gte = Math.round(message.gte);
}
if (message.in?.length) {
obj.in = message.in.map((e) => Math.round(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => Math.round(e));
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return Fixed32Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseFixed32Rules();
message.const = object.const ?? 0;
message.lt = object.lt ?? 0;
message.lte = object.lte ?? 0;
message.gt = object.gt ?? 0;
message.gte = object.gte ?? 0;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseFixed64Rules() {
return {
const: Long.UZERO,
lt: Long.UZERO,
lte: Long.UZERO,
gt: Long.UZERO,
gte: Long.UZERO,
in: [],
notIn: [],
ignoreEmpty: false,
};
}
export const Fixed64Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && !message.const.equals(Long.UZERO)) {
writer.uint32(9).fixed64(message.const.toString());
}
if (message.lt !== undefined && !message.lt.equals(Long.UZERO)) {
writer.uint32(17).fixed64(message.lt.toString());
}
if (message.lte !== undefined && !message.lte.equals(Long.UZERO)) {
writer.uint32(25).fixed64(message.lte.toString());
}
if (message.gt !== undefined && !message.gt.equals(Long.UZERO)) {
writer.uint32(33).fixed64(message.gt.toString());
}
if (message.gte !== undefined && !message.gte.equals(Long.UZERO)) {
writer.uint32(41).fixed64(message.gte.toString());
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.fixed64(v.toString());
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.fixed64(v.toString());
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseFixed64Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 9) {
break;
}
message.const = Long.fromString(reader.fixed64().toString(), true);
continue;
}
case 2: {
if (tag !== 17) {
break;
}
message.lt = Long.fromString(reader.fixed64().toString(), true);
continue;
}
case 3: {
if (tag !== 25) {
break;
}
message.lte = Long.fromString(reader.fixed64().toString(), true);
continue;
}
case 4: {
if (tag !== 33) {
break;
}
message.gt = Long.fromString(reader.fixed64().toString(), true);
continue;
}
case 5: {
if (tag !== 41) {
break;
}
message.gte = Long.fromString(reader.fixed64().toString(), true);
continue;
}
case 6: {
if (tag === 49) {
message.in.push(Long.fromString(reader.fixed64().toString(), true));
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(Long.fromString(reader.fixed64().toString(), true));
}
continue;
}
break;
}
case 7: {
if (tag === 57) {
message.notIn.push(Long.fromString(reader.fixed64().toString(), true));
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(Long.fromString(reader.fixed64().toString(), true));
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? Long.fromValue(object.const) : Long.UZERO,
lt: isSet(object.lt) ? Long.fromValue(object.lt) : Long.UZERO,
lte: isSet(object.lte) ? Long.fromValue(object.lte) : Long.UZERO,
gt: isSet(object.gt) ? Long.fromValue(object.gt) : Long.UZERO,
gte: isSet(object.gte) ? Long.fromValue(object.gte) : Long.UZERO,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => Long.fromValue(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => Long.fromValue(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && !message.const.equals(Long.UZERO)) {
obj.const = (message.const || Long.UZERO).toString();
}
if (message.lt !== undefined && !message.lt.equals(Long.UZERO)) {
obj.lt = (message.lt || Long.UZERO).toString();
}
if (message.lte !== undefined && !message.lte.equals(Long.UZERO)) {
obj.lte = (message.lte || Long.UZERO).toString();
}
if (message.gt !== undefined && !message.gt.equals(Long.UZERO)) {
obj.gt = (message.gt || Long.UZERO).toString();
}
if (message.gte !== undefined && !message.gte.equals(Long.UZERO)) {
obj.gte = (message.gte || Long.UZERO).toString();
}
if (message.in?.length) {
obj.in = message.in.map((e) => (e || Long.UZERO).toString());
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => (e || Long.UZERO).toString());
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return Fixed64Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseFixed64Rules();
message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.UZERO;
message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : Long.UZERO;
message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : Long.UZERO;
message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : Long.UZERO;
message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : Long.UZERO;
message.in = object.in?.map((e) => Long.fromValue(e)) || [];
message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseSFixed32Rules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
export const SFixed32Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(13).sfixed32(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
writer.uint32(21).sfixed32(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
writer.uint32(29).sfixed32(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
writer.uint32(37).sfixed32(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
writer.uint32(45).sfixed32(message.gte);
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.sfixed32(v);
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.sfixed32(v);
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseSFixed32Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 13) {
break;
}
message.const = reader.sfixed32();
continue;
}
case 2: {
if (tag !== 21) {
break;
}
message.lt = reader.sfixed32();
continue;
}
case 3: {
if (tag !== 29) {
break;
}
message.lte = reader.sfixed32();
continue;
}
case 4: {
if (tag !== 37) {
break;
}
message.gt = reader.sfixed32();
continue;
}
case 5: {
if (tag !== 45) {
break;
}
message.gte = reader.sfixed32();
continue;
}
case 6: {
if (tag === 53) {
message.in.push(reader.sfixed32());
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.sfixed32());
}
continue;
}
break;
}
case 7: {
if (tag === 61) {
message.notIn.push(reader.sfixed32());
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.sfixed32());
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
lt: isSet(object.lt) ? globalThis.Number(object.lt) : 0,
lte: isSet(object.lte) ? globalThis.Number(object.lte) : 0,
gt: isSet(object.gt) ? globalThis.Number(object.gt) : 0,
gte: isSet(object.gte) ? globalThis.Number(object.gte) : 0,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.lt !== undefined && message.lt !== 0) {
obj.lt = Math.round(message.lt);
}
if (message.lte !== undefined && message.lte !== 0) {
obj.lte = Math.round(message.lte);
}
if (message.gt !== undefined && message.gt !== 0) {
obj.gt = Math.round(message.gt);
}
if (message.gte !== undefined && message.gte !== 0) {
obj.gte = Math.round(message.gte);
}
if (message.in?.length) {
obj.in = message.in.map((e) => Math.round(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => Math.round(e));
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return SFixed32Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseSFixed32Rules();
message.const = object.const ?? 0;
message.lt = object.lt ?? 0;
message.lte = object.lte ?? 0;
message.gt = object.gt ?? 0;
message.gte = object.gte ?? 0;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseSFixed64Rules() {
return {
const: Long.ZERO,
lt: Long.ZERO,
lte: Long.ZERO,
gt: Long.ZERO,
gte: Long.ZERO,
in: [],
notIn: [],
ignoreEmpty: false,
};
}
export const SFixed64Rules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
writer.uint32(9).sfixed64(message.const.toString());
}
if (message.lt !== undefined && !message.lt.equals(Long.ZERO)) {
writer.uint32(17).sfixed64(message.lt.toString());
}
if (message.lte !== undefined && !message.lte.equals(Long.ZERO)) {
writer.uint32(25).sfixed64(message.lte.toString());
}
if (message.gt !== undefined && !message.gt.equals(Long.ZERO)) {
writer.uint32(33).sfixed64(message.gt.toString());
}
if (message.gte !== undefined && !message.gte.equals(Long.ZERO)) {
writer.uint32(41).sfixed64(message.gte.toString());
}
writer.uint32(50).fork();
for (const v of message.in) {
writer.sfixed64(v.toString());
}
writer.join();
writer.uint32(58).fork();
for (const v of message.notIn) {
writer.sfixed64(v.toString());
}
writer.join();
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseSFixed64Rules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 9) {
break;
}
message.const = Long.fromString(reader.sfixed64().toString());
continue;
}
case 2: {
if (tag !== 17) {
break;
}
message.lt = Long.fromString(reader.sfixed64().toString());
continue;
}
case 3: {
if (tag !== 25) {
break;
}
message.lte = Long.fromString(reader.sfixed64().toString());
continue;
}
case 4: {
if (tag !== 33) {
break;
}
message.gt = Long.fromString(reader.sfixed64().toString());
continue;
}
case 5: {
if (tag !== 41) {
break;
}
message.gte = Long.fromString(reader.sfixed64().toString());
continue;
}
case 6: {
if (tag === 49) {
message.in.push(Long.fromString(reader.sfixed64().toString()));
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(Long.fromString(reader.sfixed64().toString()));
}
continue;
}
break;
}
case 7: {
if (tag === 57) {
message.notIn.push(Long.fromString(reader.sfixed64().toString()));
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(Long.fromString(reader.sfixed64().toString()));
}
continue;
}
break;
}
case 8: {
if (tag !== 64) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? Long.fromValue(object.const) : Long.ZERO,
lt: isSet(object.lt) ? Long.fromValue(object.lt) : Long.ZERO,
lte: isSet(object.lte) ? Long.fromValue(object.lte) : Long.ZERO,
gt: isSet(object.gt) ? Long.fromValue(object.gt) : Long.ZERO,
gte: isSet(object.gte) ? Long.fromValue(object.gte) : Long.ZERO,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => Long.fromValue(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => Long.fromValue(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
obj.const = (message.const || Long.ZERO).toString();
}
if (message.lt !== undefined && !message.lt.equals(Long.ZERO)) {
obj.lt = (message.lt || Long.ZERO).toString();
}
if (message.lte !== undefined && !message.lte.equals(Long.ZERO)) {
obj.lte = (message.lte || Long.ZERO).toString();
}
if (message.gt !== undefined && !message.gt.equals(Long.ZERO)) {
obj.gt = (message.gt || Long.ZERO).toString();
}
if (message.gte !== undefined && !message.gte.equals(Long.ZERO)) {
obj.gte = (message.gte || Long.ZERO).toString();
}
if (message.in?.length) {
obj.in = message.in.map((e) => (e || Long.ZERO).toString());
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => (e || Long.ZERO).toString());
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return SFixed64Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseSFixed64Rules();
message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.ZERO;
message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : Long.ZERO;
message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : Long.ZERO;
message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : Long.ZERO;
message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : Long.ZERO;
message.in = object.in?.map((e) => Long.fromValue(e)) || [];
message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseBoolRules() {
return { const: false };
}
export const BoolRules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== false) {
writer.uint32(8).bool(message.const);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseBoolRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.const = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return { const: isSet(object.const) ? globalThis.Boolean(object.const) : false };
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== false) {
obj.const = message.const;
}
return obj;
},
create(base) {
return BoolRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseBoolRules();
message.const = object.const ?? false;
return message;
},
};
function createBaseStringRules() {
return {
const: "",
len: Long.UZERO,
minLen: Long.UZERO,
maxLen: Long.UZERO,
lenBytes: Long.UZERO,
minBytes: Long.UZERO,
maxBytes: Long.UZERO,
pattern: "",
prefix: "",
suffix: "",
contains: "",
notContains: "",
in: [],
notIn: [],
email: undefined,
hostname: undefined,
ip: undefined,
ipv4: undefined,
ipv6: undefined,
uri: undefined,
uriRef: undefined,
address: undefined,
uuid: undefined,
wellKnownRegex: undefined,
strict: true,
ignoreEmpty: false,
};
}
export const StringRules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== "") {
writer.uint32(10).string(message.const);
}
if (message.len !== undefined && !message.len.equals(Long.UZERO)) {
writer.uint32(152).uint64(message.len.toString());
}
if (message.minLen !== undefined && !message.minLen.equals(Long.UZERO)) {
writer.uint32(16).uint64(message.minLen.toString());
}
if (message.maxLen !== undefined && !message.maxLen.equals(Long.UZERO)) {
writer.uint32(24).uint64(message.maxLen.toString());
}
if (message.lenBytes !== undefined && !message.lenBytes.equals(Long.UZERO)) {
writer.uint32(160).uint64(message.lenBytes.toString());
}
if (message.minBytes !== undefined && !message.minBytes.equals(Long.UZERO)) {
writer.uint32(32).uint64(message.minBytes.toString());
}
if (message.maxBytes !== undefined && !message.maxBytes.equals(Long.UZERO)) {
writer.uint32(40).uint64(message.maxBytes.toString());
}
if (message.pattern !== undefined && message.pattern !== "") {
writer.uint32(50).string(message.pattern);
}
if (message.prefix !== undefined && message.prefix !== "") {
writer.uint32(58).string(message.prefix);
}
if (message.suffix !== undefined && message.suffix !== "") {
writer.uint32(66).string(message.suffix);
}
if (message.contains !== undefined && message.contains !== "") {
writer.uint32(74).string(message.contains);
}
if (message.notContains !== undefined && message.notContains !== "") {
writer.uint32(186).string(message.notContains);
}
for (const v of message.in) {
writer.uint32(82).string(v);
}
for (const v of message.notIn) {
writer.uint32(90).string(v);
}
if (message.email !== undefined) {
writer.uint32(96).bool(message.email);
}
if (message.hostname !== undefined) {
writer.uint32(104).bool(message.hostname);
}
if (message.ip !== undefined) {
writer.uint32(112).bool(message.ip);
}
if (message.ipv4 !== undefined) {
writer.uint32(120).bool(message.ipv4);
}
if (message.ipv6 !== undefined) {
writer.uint32(128).bool(message.ipv6);
}
if (message.uri !== undefined) {
writer.uint32(136).bool(message.uri);
}
if (message.uriRef !== undefined) {
writer.uint32(144).bool(message.uriRef);
}
if (message.address !== undefined) {
writer.uint32(168).bool(message.address);
}
if (message.uuid !== undefined) {
writer.uint32(176).bool(message.uuid);
}
if (message.wellKnownRegex !== undefined) {
writer.uint32(192).int32(message.wellKnownRegex);
}
if (message.strict !== undefined && message.strict !== true) {
writer.uint32(200).bool(message.strict);
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(208).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseStringRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 10) {
break;
}
message.const = reader.string();
continue;
}
case 19: {
if (tag !== 152) {
break;
}
message.len = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.minLen = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.maxLen = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 20: {
if (tag !== 160) {
break;
}
message.lenBytes = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.minBytes = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.maxBytes = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 6: {
if (tag !== 50) {
break;
}
message.pattern = reader.string();
continue;
}
case 7: {
if (tag !== 58) {
break;
}
message.prefix = reader.string();
continue;
}
case 8: {
if (tag !== 66) {
break;
}
message.suffix = reader.string();
continue;
}
case 9: {
if (tag !== 74) {
break;
}
message.contains = reader.string();
continue;
}
case 23: {
if (tag !== 186) {
break;
}
message.notContains = reader.string();
continue;
}
case 10: {
if (tag !== 82) {
break;
}
message.in.push(reader.string());
continue;
}
case 11: {
if (tag !== 90) {
break;
}
message.notIn.push(reader.string());
continue;
}
case 12: {
if (tag !== 96) {
break;
}
message.email = reader.bool();
continue;
}
case 13: {
if (tag !== 104) {
break;
}
message.hostname = reader.bool();
continue;
}
case 14: {
if (tag !== 112) {
break;
}
message.ip = reader.bool();
continue;
}
case 15: {
if (tag !== 120) {
break;
}
message.ipv4 = reader.bool();
continue;
}
case 16: {
if (tag !== 128) {
break;
}
message.ipv6 = reader.bool();
continue;
}
case 17: {
if (tag !== 136) {
break;
}
message.uri = reader.bool();
continue;
}
case 18: {
if (tag !== 144) {
break;
}
message.uriRef = reader.bool();
continue;
}
case 21: {
if (tag !== 168) {
break;
}
message.address = reader.bool();
continue;
}
case 22: {
if (tag !== 176) {
break;
}
message.uuid = reader.bool();
continue;
}
case 24: {
if (tag !== 192) {
break;
}
message.wellKnownRegex = reader.int32();
continue;
}
case 25: {
if (tag !== 200) {
break;
}
message.strict = reader.bool();
continue;
}
case 26: {
if (tag !== 208) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.String(object.const) : "",
len: isSet(object.len) ? Long.fromValue(object.len) : Long.UZERO,
minLen: isSet(object.minLen) ? Long.fromValue(object.minLen) : Long.UZERO,
maxLen: isSet(object.maxLen) ? Long.fromValue(object.maxLen) : Long.UZERO,
lenBytes: isSet(object.lenBytes) ? Long.fromValue(object.lenBytes) : Long.UZERO,
minBytes: isSet(object.minBytes) ? Long.fromValue(object.minBytes) : Long.UZERO,
maxBytes: isSet(object.maxBytes) ? Long.fromValue(object.maxBytes) : Long.UZERO,
pattern: isSet(object.pattern) ? globalThis.String(object.pattern) : "",
prefix: isSet(object.prefix) ? globalThis.String(object.prefix) : "",
suffix: isSet(object.suffix) ? globalThis.String(object.suffix) : "",
contains: isSet(object.contains) ? globalThis.String(object.contains) : "",
notContains: isSet(object.notContains) ? globalThis.String(object.notContains) : "",
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.String(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.String(e)) : [],
email: isSet(object.email) ? globalThis.Boolean(object.email) : undefined,
hostname: isSet(object.hostname) ? globalThis.Boolean(object.hostname) : undefined,
ip: isSet(object.ip) ? globalThis.Boolean(object.ip) : undefined,
ipv4: isSet(object.ipv4) ? globalThis.Boolean(object.ipv4) : undefined,
ipv6: isSet(object.ipv6) ? globalThis.Boolean(object.ipv6) : undefined,
uri: isSet(object.uri) ? globalThis.Boolean(object.uri) : undefined,
uriRef: isSet(object.uriRef) ? globalThis.Boolean(object.uriRef) : undefined,
address: isSet(object.address) ? globalThis.Boolean(object.address) : undefined,
uuid: isSet(object.uuid) ? globalThis.Boolean(object.uuid) : undefined,
wellKnownRegex: isSet(object.wellKnownRegex) ? knownRegexFromJSON(object.wellKnownRegex) : undefined,
strict: isSet(object.strict) ? globalThis.Boolean(object.strict) : true,
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== "") {
obj.const = message.const;
}
if (message.len !== undefined && !message.len.equals(Long.UZERO)) {
obj.len = (message.len || Long.UZERO).toString();
}
if (message.minLen !== undefined && !message.minLen.equals(Long.UZERO)) {
obj.minLen = (message.minLen || Long.UZERO).toString();
}
if (message.maxLen !== undefined && !message.maxLen.equals(Long.UZERO)) {
obj.maxLen = (message.maxLen || Long.UZERO).toString();
}
if (message.lenBytes !== undefined && !message.lenBytes.equals(Long.UZERO)) {
obj.lenBytes = (message.lenBytes || Long.UZERO).toString();
}
if (message.minBytes !== undefined && !message.minBytes.equals(Long.UZERO)) {
obj.minBytes = (message.minBytes || Long.UZERO).toString();
}
if (message.maxBytes !== undefined && !message.maxBytes.equals(Long.UZERO)) {
obj.maxBytes = (message.maxBytes || Long.UZERO).toString();
}
if (message.pattern !== undefined && message.pattern !== "") {
obj.pattern = message.pattern;
}
if (message.prefix !== undefined && message.prefix !== "") {
obj.prefix = message.prefix;
}
if (message.suffix !== undefined && message.suffix !== "") {
obj.suffix = message.suffix;
}
if (message.contains !== undefined && message.contains !== "") {
obj.contains = message.contains;
}
if (message.notContains !== undefined && message.notContains !== "") {
obj.notContains = message.notContains;
}
if (message.in?.length) {
obj.in = message.in;
}
if (message.notIn?.length) {
obj.notIn = message.notIn;
}
if (message.email !== undefined) {
obj.email = message.email;
}
if (message.hostname !== undefined) {
obj.hostname = message.hostname;
}
if (message.ip !== undefined) {
obj.ip = message.ip;
}
if (message.ipv4 !== undefined) {
obj.ipv4 = message.ipv4;
}
if (message.ipv6 !== undefined) {
obj.ipv6 = message.ipv6;
}
if (message.uri !== undefined) {
obj.uri = message.uri;
}
if (message.uriRef !== undefined) {
obj.uriRef = message.uriRef;
}
if (message.address !== undefined) {
obj.address = message.address;
}
if (message.uuid !== undefined) {
obj.uuid = message.uuid;
}
if (message.wellKnownRegex !== undefined) {
obj.wellKnownRegex = knownRegexToJSON(message.wellKnownRegex);
}
if (message.strict !== undefined && message.strict !== true) {
obj.strict = message.strict;
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return StringRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseStringRules();
message.const = object.const ?? "";
message.len = (object.len !== undefined && object.len !== null) ? Long.fromValue(object.len) : Long.UZERO;
message.minLen = (object.minLen !== undefined && object.minLen !== null)
? Long.fromValue(object.minLen)
: Long.UZERO;
message.maxLen = (object.maxLen !== undefined && object.maxLen !== null)
? Long.fromValue(object.maxLen)
: Long.UZERO;
message.lenBytes = (object.lenBytes !== undefined && object.lenBytes !== null)
? Long.fromValue(object.lenBytes)
: Long.UZERO;
message.minBytes = (object.minBytes !== undefined && object.minBytes !== null)
? Long.fromValue(object.minBytes)
: Long.UZERO;
message.maxBytes = (object.maxBytes !== undefined && object.maxBytes !== null)
? Long.fromValue(object.maxBytes)
: Long.UZERO;
message.pattern = object.pattern ?? "";
message.prefix = object.prefix ?? "";
message.suffix = object.suffix ?? "";
message.contains = object.contains ?? "";
message.notContains = object.notContains ?? "";
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.email = object.email ?? undefined;
message.hostname = object.hostname ?? undefined;
message.ip = object.ip ?? undefined;
message.ipv4 = object.ipv4 ?? undefined;
message.ipv6 = object.ipv6 ?? undefined;
message.uri = object.uri ?? undefined;
message.uriRef = object.uriRef ?? undefined;
message.address = object.address ?? undefined;
message.uuid = object.uuid ?? undefined;
message.wellKnownRegex = object.wellKnownRegex ?? undefined;
message.strict = object.strict ?? true;
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseBytesRules() {
return {
const: Buffer.alloc(0),
len: Long.UZERO,
minLen: Long.UZERO,
maxLen: Long.UZERO,
pattern: "",
prefix: Buffer.alloc(0),
suffix: Buffer.alloc(0),
contains: Buffer.alloc(0),
in: [],
notIn: [],
ip: undefined,
ipv4: undefined,
ipv6: undefined,
ignoreEmpty: false,
};
}
export const BytesRules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const.length !== 0) {
writer.uint32(10).bytes(message.const);
}
if (message.len !== undefined && !message.len.equals(Long.UZERO)) {
writer.uint32(104).uint64(message.len.toString());
}
if (message.minLen !== undefined && !message.minLen.equals(Long.UZERO)) {
writer.uint32(16).uint64(message.minLen.toString());
}
if (message.maxLen !== undefined && !message.maxLen.equals(Long.UZERO)) {
writer.uint32(24).uint64(message.maxLen.toString());
}
if (message.pattern !== undefined && message.pattern !== "") {
writer.uint32(34).string(message.pattern);
}
if (message.prefix !== undefined && message.prefix.length !== 0) {
writer.uint32(42).bytes(message.prefix);
}
if (message.suffix !== undefined && message.suffix.length !== 0) {
writer.uint32(50).bytes(message.suffix);
}
if (message.contains !== undefined && message.contains.length !== 0) {
writer.uint32(58).bytes(message.contains);
}
for (const v of message.in) {
writer.uint32(66).bytes(v);
}
for (const v of message.notIn) {
writer.uint32(74).bytes(v);
}
if (message.ip !== undefined) {
writer.uint32(80).bool(message.ip);
}
if (message.ipv4 !== undefined) {
writer.uint32(88).bool(message.ipv4);
}
if (message.ipv6 !== undefined) {
writer.uint32(96).bool(message.ipv6);
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(112).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseBytesRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 10) {
break;
}
message.const = Buffer.from(reader.bytes());
continue;
}
case 13: {
if (tag !== 104) {
break;
}
message.len = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.minLen = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.maxLen = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.pattern = reader.string();
continue;
}
case 5: {
if (tag !== 42) {
break;
}
message.prefix = Buffer.from(reader.bytes());
continue;
}
case 6: {
if (tag !== 50) {
break;
}
message.suffix = Buffer.from(reader.bytes());
continue;
}
case 7: {
if (tag !== 58) {
break;
}
message.contains = Buffer.from(reader.bytes());
continue;
}
case 8: {
if (tag !== 66) {
break;
}
message.in.push(Buffer.from(reader.bytes()));
continue;
}
case 9: {
if (tag !== 74) {
break;
}
message.notIn.push(Buffer.from(reader.bytes()));
continue;
}
case 10: {
if (tag !== 80) {
break;
}
message.ip = reader.bool();
continue;
}
case 11: {
if (tag !== 88) {
break;
}
message.ipv4 = reader.bool();
continue;
}
case 12: {
if (tag !== 96) {
break;
}
message.ipv6 = reader.bool();
continue;
}
case 14: {
if (tag !== 112) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? Buffer.from(bytesFromBase64(object.const)) : Buffer.alloc(0),
len: isSet(object.len) ? Long.fromValue(object.len) : Long.UZERO,
minLen: isSet(object.minLen) ? Long.fromValue(object.minLen) : Long.UZERO,
maxLen: isSet(object.maxLen) ? Long.fromValue(object.maxLen) : Long.UZERO,
pattern: isSet(object.pattern) ? globalThis.String(object.pattern) : "",
prefix: isSet(object.prefix) ? Buffer.from(bytesFromBase64(object.prefix)) : Buffer.alloc(0),
suffix: isSet(object.suffix) ? Buffer.from(bytesFromBase64(object.suffix)) : Buffer.alloc(0),
contains: isSet(object.contains) ? Buffer.from(bytesFromBase64(object.contains)) : Buffer.alloc(0),
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => Buffer.from(bytesFromBase64(e))) : [],
notIn: globalThis.Array.isArray(object?.notIn)
? object.notIn.map((e) => Buffer.from(bytesFromBase64(e)))
: [],
ip: isSet(object.ip) ? globalThis.Boolean(object.ip) : undefined,
ipv4: isSet(object.ipv4) ? globalThis.Boolean(object.ipv4) : undefined,
ipv6: isSet(object.ipv6) ? globalThis.Boolean(object.ipv6) : undefined,
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const.length !== 0) {
obj.const = base64FromBytes(message.const);
}
if (message.len !== undefined && !message.len.equals(Long.UZERO)) {
obj.len = (message.len || Long.UZERO).toString();
}
if (message.minLen !== undefined && !message.minLen.equals(Long.UZERO)) {
obj.minLen = (message.minLen || Long.UZERO).toString();
}
if (message.maxLen !== undefined && !message.maxLen.equals(Long.UZERO)) {
obj.maxLen = (message.maxLen || Long.UZERO).toString();
}
if (message.pattern !== undefined && message.pattern !== "") {
obj.pattern = message.pattern;
}
if (message.prefix !== undefined && message.prefix.length !== 0) {
obj.prefix = base64FromBytes(message.prefix);
}
if (message.suffix !== undefined && message.suffix.length !== 0) {
obj.suffix = base64FromBytes(message.suffix);
}
if (message.contains !== undefined && message.contains.length !== 0) {
obj.contains = base64FromBytes(message.contains);
}
if (message.in?.length) {
obj.in = message.in.map((e) => base64FromBytes(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => base64FromBytes(e));
}
if (message.ip !== undefined) {
obj.ip = message.ip;
}
if (message.ipv4 !== undefined) {
obj.ipv4 = message.ipv4;
}
if (message.ipv6 !== undefined) {
obj.ipv6 = message.ipv6;
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return BytesRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseBytesRules();
message.const = object.const ?? Buffer.alloc(0);
message.len = (object.len !== undefined && object.len !== null) ? Long.fromValue(object.len) : Long.UZERO;
message.minLen = (object.minLen !== undefined && object.minLen !== null)
? Long.fromValue(object.minLen)
: Long.UZERO;
message.maxLen = (object.maxLen !== undefined && object.maxLen !== null)
? Long.fromValue(object.maxLen)
: Long.UZERO;
message.pattern = object.pattern ?? "";
message.prefix = object.prefix ?? Buffer.alloc(0);
message.suffix = object.suffix ?? Buffer.alloc(0);
message.contains = object.contains ?? Buffer.alloc(0);
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
message.ip = object.ip ?? undefined;
message.ipv4 = object.ipv4 ?? undefined;
message.ipv6 = object.ipv6 ?? undefined;
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseEnumRules() {
return { const: 0, definedOnly: false, in: [], notIn: [] };
}
export const EnumRules = {
encode(message, writer = new BinaryWriter()) {
if (message.const !== undefined && message.const !== 0) {
writer.uint32(8).int32(message.const);
}
if (message.definedOnly !== undefined && message.definedOnly !== false) {
writer.uint32(16).bool(message.definedOnly);
}
writer.uint32(26).fork();
for (const v of message.in) {
writer.int32(v);
}
writer.join();
writer.uint32(34).fork();
for (const v of message.notIn) {
writer.int32(v);
}
writer.join();
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseEnumRules();
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.definedOnly = reader.bool();
continue;
}
case 3: {
if (tag === 24) {
message.in.push(reader.int32());
continue;
}
if (tag === 26) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(reader.int32());
}
continue;
}
break;
}
case 4: {
if (tag === 32) {
message.notIn.push(reader.int32());
continue;
}
if (tag === 34) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(reader.int32());
}
continue;
}
break;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
const: isSet(object.const) ? globalThis.Number(object.const) : 0,
definedOnly: isSet(object.definedOnly) ? globalThis.Boolean(object.definedOnly) : false,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.Number(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.Number(e)) : [],
};
},
toJSON(message) {
const obj = {};
if (message.const !== undefined && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.definedOnly !== undefined && message.definedOnly !== false) {
obj.definedOnly = message.definedOnly;
}
if (message.in?.length) {
obj.in = message.in.map((e) => Math.round(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => Math.round(e));
}
return obj;
},
create(base) {
return EnumRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseEnumRules();
message.const = object.const ?? 0;
message.definedOnly = object.definedOnly ?? false;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
return message;
},
};
function createBaseMessageRules() {
return { skip: false, required: false };
}
export const MessageRules = {
encode(message, writer = new BinaryWriter()) {
if (message.skip !== undefined && message.skip !== false) {
writer.uint32(8).bool(message.skip);
}
if (message.required !== undefined && message.required !== false) {
writer.uint32(16).bool(message.required);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new 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.skip = reader.bool();
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.required = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
skip: isSet(object.skip) ? globalThis.Boolean(object.skip) : false,
required: isSet(object.required) ? globalThis.Boolean(object.required) : false,
};
},
toJSON(message) {
const obj = {};
if (message.skip !== undefined && message.skip !== false) {
obj.skip = message.skip;
}
if (message.required !== undefined && message.required !== false) {
obj.required = message.required;
}
return obj;
},
create(base) {
return MessageRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseMessageRules();
message.skip = object.skip ?? false;
message.required = object.required ?? false;
return message;
},
};
function createBaseRepeatedRules() {
return { minItems: Long.UZERO, maxItems: Long.UZERO, unique: false, items: undefined, ignoreEmpty: false };
}
export const RepeatedRules = {
encode(message, writer = new BinaryWriter()) {
if (message.minItems !== undefined && !message.minItems.equals(Long.UZERO)) {
writer.uint32(8).uint64(message.minItems.toString());
}
if (message.maxItems !== undefined && !message.maxItems.equals(Long.UZERO)) {
writer.uint32(16).uint64(message.maxItems.toString());
}
if (message.unique !== undefined && message.unique !== false) {
writer.uint32(24).bool(message.unique);
}
if (message.items !== undefined) {
FieldRules.encode(message.items, writer.uint32(34).fork()).join();
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(40).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseRepeatedRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.minItems = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.maxItems = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.unique = reader.bool();
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.items = FieldRules.decode(reader, reader.uint32());
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
minItems: isSet(object.minItems) ? Long.fromValue(object.minItems) : Long.UZERO,
maxItems: isSet(object.maxItems) ? Long.fromValue(object.maxItems) : Long.UZERO,
unique: isSet(object.unique) ? globalThis.Boolean(object.unique) : false,
items: isSet(object.items) ? FieldRules.fromJSON(object.items) : undefined,
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.minItems !== undefined && !message.minItems.equals(Long.UZERO)) {
obj.minItems = (message.minItems || Long.UZERO).toString();
}
if (message.maxItems !== undefined && !message.maxItems.equals(Long.UZERO)) {
obj.maxItems = (message.maxItems || Long.UZERO).toString();
}
if (message.unique !== undefined && message.unique !== false) {
obj.unique = message.unique;
}
if (message.items !== undefined) {
obj.items = FieldRules.toJSON(message.items);
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return RepeatedRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseRepeatedRules();
message.minItems = (object.minItems !== undefined && object.minItems !== null)
? Long.fromValue(object.minItems)
: Long.UZERO;
message.maxItems = (object.maxItems !== undefined && object.maxItems !== null)
? Long.fromValue(object.maxItems)
: Long.UZERO;
message.unique = object.unique ?? false;
message.items = (object.items !== undefined && object.items !== null)
? FieldRules.fromPartial(object.items)
: undefined;
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseMapRules() {
return {
minPairs: Long.UZERO,
maxPairs: Long.UZERO,
noSparse: false,
keys: undefined,
values: undefined,
ignoreEmpty: false,
};
}
export const MapRules = {
encode(message, writer = new BinaryWriter()) {
if (message.minPairs !== undefined && !message.minPairs.equals(Long.UZERO)) {
writer.uint32(8).uint64(message.minPairs.toString());
}
if (message.maxPairs !== undefined && !message.maxPairs.equals(Long.UZERO)) {
writer.uint32(16).uint64(message.maxPairs.toString());
}
if (message.noSparse !== undefined && message.noSparse !== false) {
writer.uint32(24).bool(message.noSparse);
}
if (message.keys !== undefined) {
FieldRules.encode(message.keys, writer.uint32(34).fork()).join();
}
if (message.values !== undefined) {
FieldRules.encode(message.values, writer.uint32(42).fork()).join();
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
writer.uint32(48).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseMapRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.minPairs = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.maxPairs = Long.fromString(reader.uint64().toString(), true);
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.noSparse = reader.bool();
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.keys = FieldRules.decode(reader, reader.uint32());
continue;
}
case 5: {
if (tag !== 42) {
break;
}
message.values = FieldRules.decode(reader, reader.uint32());
continue;
}
case 6: {
if (tag !== 48) {
break;
}
message.ignoreEmpty = reader.bool();
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
minPairs: isSet(object.minPairs) ? Long.fromValue(object.minPairs) : Long.UZERO,
maxPairs: isSet(object.maxPairs) ? Long.fromValue(object.maxPairs) : Long.UZERO,
noSparse: isSet(object.noSparse) ? globalThis.Boolean(object.noSparse) : false,
keys: isSet(object.keys) ? FieldRules.fromJSON(object.keys) : undefined,
values: isSet(object.values) ? FieldRules.fromJSON(object.values) : undefined,
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
};
},
toJSON(message) {
const obj = {};
if (message.minPairs !== undefined && !message.minPairs.equals(Long.UZERO)) {
obj.minPairs = (message.minPairs || Long.UZERO).toString();
}
if (message.maxPairs !== undefined && !message.maxPairs.equals(Long.UZERO)) {
obj.maxPairs = (message.maxPairs || Long.UZERO).toString();
}
if (message.noSparse !== undefined && message.noSparse !== false) {
obj.noSparse = message.noSparse;
}
if (message.keys !== undefined) {
obj.keys = FieldRules.toJSON(message.keys);
}
if (message.values !== undefined) {
obj.values = FieldRules.toJSON(message.values);
}
if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return MapRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseMapRules();
message.minPairs = (object.minPairs !== undefined && object.minPairs !== null)
? Long.fromValue(object.minPairs)
: Long.UZERO;
message.maxPairs = (object.maxPairs !== undefined && object.maxPairs !== null)
? Long.fromValue(object.maxPairs)
: Long.UZERO;
message.noSparse = object.noSparse ?? false;
message.keys = (object.keys !== undefined && object.keys !== null)
? FieldRules.fromPartial(object.keys)
: undefined;
message.values = (object.values !== undefined && object.values !== null)
? FieldRules.fromPartial(object.values)
: undefined;
message.ignoreEmpty = object.ignoreEmpty ?? false;
return message;
},
};
function createBaseAnyRules() {
return { required: false, in: [], notIn: [] };
}
export const AnyRules = {
encode(message, writer = new BinaryWriter()) {
if (message.required !== undefined && message.required !== false) {
writer.uint32(8).bool(message.required);
}
for (const v of message.in) {
writer.uint32(18).string(v);
}
for (const v of message.notIn) {
writer.uint32(26).string(v);
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseAnyRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.required = reader.bool();
continue;
}
case 2: {
if (tag !== 18) {
break;
}
message.in.push(reader.string());
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.notIn.push(reader.string());
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
required: isSet(object.required) ? globalThis.Boolean(object.required) : false,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => globalThis.String(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => globalThis.String(e)) : [],
};
},
toJSON(message) {
const obj = {};
if (message.required !== undefined && message.required !== false) {
obj.required = message.required;
}
if (message.in?.length) {
obj.in = message.in;
}
if (message.notIn?.length) {
obj.notIn = message.notIn;
}
return obj;
},
create(base) {
return AnyRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseAnyRules();
message.required = object.required ?? false;
message.in = object.in?.map((e) => e) || [];
message.notIn = object.notIn?.map((e) => e) || [];
return message;
},
};
function createBaseDurationRules() {
return {
required: false,
const: undefined,
lt: undefined,
lte: undefined,
gt: undefined,
gte: undefined,
in: [],
notIn: [],
};
}
export const DurationRules = {
encode(message, writer = new BinaryWriter()) {
if (message.required !== undefined && message.required !== false) {
writer.uint32(8).bool(message.required);
}
if (message.const !== undefined) {
Duration.encode(message.const, writer.uint32(18).fork()).join();
}
if (message.lt !== undefined) {
Duration.encode(message.lt, writer.uint32(26).fork()).join();
}
if (message.lte !== undefined) {
Duration.encode(message.lte, writer.uint32(34).fork()).join();
}
if (message.gt !== undefined) {
Duration.encode(message.gt, writer.uint32(42).fork()).join();
}
if (message.gte !== undefined) {
Duration.encode(message.gte, writer.uint32(50).fork()).join();
}
for (const v of message.in) {
Duration.encode(v, writer.uint32(58).fork()).join();
}
for (const v of message.notIn) {
Duration.encode(v, writer.uint32(66).fork()).join();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseDurationRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.required = reader.bool();
continue;
}
case 2: {
if (tag !== 18) {
break;
}
message.const = Duration.decode(reader, reader.uint32());
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.lt = Duration.decode(reader, reader.uint32());
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.lte = Duration.decode(reader, reader.uint32());
continue;
}
case 5: {
if (tag !== 42) {
break;
}
message.gt = Duration.decode(reader, reader.uint32());
continue;
}
case 6: {
if (tag !== 50) {
break;
}
message.gte = Duration.decode(reader, reader.uint32());
continue;
}
case 7: {
if (tag !== 58) {
break;
}
message.in.push(Duration.decode(reader, reader.uint32()));
continue;
}
case 8: {
if (tag !== 66) {
break;
}
message.notIn.push(Duration.decode(reader, reader.uint32()));
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
required: isSet(object.required) ? globalThis.Boolean(object.required) : false,
const: isSet(object.const) ? Duration.fromJSON(object.const) : undefined,
lt: isSet(object.lt) ? Duration.fromJSON(object.lt) : undefined,
lte: isSet(object.lte) ? Duration.fromJSON(object.lte) : undefined,
gt: isSet(object.gt) ? Duration.fromJSON(object.gt) : undefined,
gte: isSet(object.gte) ? Duration.fromJSON(object.gte) : undefined,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => Duration.fromJSON(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => Duration.fromJSON(e)) : [],
};
},
toJSON(message) {
const obj = {};
if (message.required !== undefined && message.required !== false) {
obj.required = message.required;
}
if (message.const !== undefined) {
obj.const = Duration.toJSON(message.const);
}
if (message.lt !== undefined) {
obj.lt = Duration.toJSON(message.lt);
}
if (message.lte !== undefined) {
obj.lte = Duration.toJSON(message.lte);
}
if (message.gt !== undefined) {
obj.gt = Duration.toJSON(message.gt);
}
if (message.gte !== undefined) {
obj.gte = Duration.toJSON(message.gte);
}
if (message.in?.length) {
obj.in = message.in.map((e) => Duration.toJSON(e));
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => Duration.toJSON(e));
}
return obj;
},
create(base) {
return DurationRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseDurationRules();
message.required = object.required ?? false;
message.const = (object.const !== undefined && object.const !== null)
? Duration.fromPartial(object.const)
: undefined;
message.lt = (object.lt !== undefined && object.lt !== null) ? Duration.fromPartial(object.lt) : undefined;
message.lte = (object.lte !== undefined && object.lte !== null) ? Duration.fromPartial(object.lte) : undefined;
message.gt = (object.gt !== undefined && object.gt !== null) ? Duration.fromPartial(object.gt) : undefined;
message.gte = (object.gte !== undefined && object.gte !== null) ? Duration.fromPartial(object.gte) : undefined;
message.in = object.in?.map((e) => Duration.fromPartial(e)) || [];
message.notIn = object.notIn?.map((e) => Duration.fromPartial(e)) || [];
return message;
},
};
function createBaseTimestampRules() {
return {
required: false,
const: undefined,
lt: undefined,
lte: undefined,
gt: undefined,
gte: undefined,
ltNow: false,
gtNow: false,
within: undefined,
};
}
export const TimestampRules = {
encode(message, writer = new BinaryWriter()) {
if (message.required !== undefined && message.required !== false) {
writer.uint32(8).bool(message.required);
}
if (message.const !== undefined) {
Timestamp.encode(toTimestamp(message.const), writer.uint32(18).fork()).join();
}
if (message.lt !== undefined) {
Timestamp.encode(toTimestamp(message.lt), writer.uint32(26).fork()).join();
}
if (message.lte !== undefined) {
Timestamp.encode(toTimestamp(message.lte), writer.uint32(34).fork()).join();
}
if (message.gt !== undefined) {
Timestamp.encode(toTimestamp(message.gt), writer.uint32(42).fork()).join();
}
if (message.gte !== undefined) {
Timestamp.encode(toTimestamp(message.gte), writer.uint32(50).fork()).join();
}
if (message.ltNow !== undefined && message.ltNow !== false) {
writer.uint32(56).bool(message.ltNow);
}
if (message.gtNow !== undefined && message.gtNow !== false) {
writer.uint32(64).bool(message.gtNow);
}
if (message.within !== undefined) {
Duration.encode(message.within, writer.uint32(74).fork()).join();
}
return writer;
},
decode(input, length) {
const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
const end = length === undefined ? reader.len : reader.pos + length;
const message = createBaseTimestampRules();
while (reader.pos < end) {
const tag = reader.uint32();
switch (tag >>> 3) {
case 1: {
if (tag !== 8) {
break;
}
message.required = reader.bool();
continue;
}
case 2: {
if (tag !== 18) {
break;
}
message.const = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
continue;
}
case 3: {
if (tag !== 26) {
break;
}
message.lt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
continue;
}
case 4: {
if (tag !== 34) {
break;
}
message.lte = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
continue;
}
case 5: {
if (tag !== 42) {
break;
}
message.gt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
continue;
}
case 6: {
if (tag !== 50) {
break;
}
message.gte = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
continue;
}
case 7: {
if (tag !== 56) {
break;
}
message.ltNow = reader.bool();
continue;
}
case 8: {
if (tag !== 64) {
break;
}
message.gtNow = reader.bool();
continue;
}
case 9: {
if (tag !== 74) {
break;
}
message.within = Duration.decode(reader, reader.uint32());
continue;
}
}
if ((tag & 7) === 4 || tag === 0) {
break;
}
reader.skip(tag & 7);
}
return message;
},
fromJSON(object) {
return {
required: isSet(object.required) ? globalThis.Boolean(object.required) : false,
const: isSet(object.const) ? fromJsonTimestamp(object.const) : undefined,
lt: isSet(object.lt) ? fromJsonTimestamp(object.lt) : undefined,
lte: isSet(object.lte) ? fromJsonTimestamp(object.lte) : undefined,
gt: isSet(object.gt) ? fromJsonTimestamp(object.gt) : undefined,
gte: isSet(object.gte) ? fromJsonTimestamp(object.gte) : undefined,
ltNow: isSet(object.ltNow) ? globalThis.Boolean(object.ltNow) : false,
gtNow: isSet(object.gtNow) ? globalThis.Boolean(object.gtNow) : false,
within: isSet(object.within) ? Duration.fromJSON(object.within) : undefined,
};
},
toJSON(message) {
const obj = {};
if (message.required !== undefined && message.required !== false) {
obj.required = message.required;
}
if (message.const !== undefined) {
obj.const = message.const.toISOString();
}
if (message.lt !== undefined) {
obj.lt = message.lt.toISOString();
}
if (message.lte !== undefined) {
obj.lte = message.lte.toISOString();
}
if (message.gt !== undefined) {
obj.gt = message.gt.toISOString();
}
if (message.gte !== undefined) {
obj.gte = message.gte.toISOString();
}
if (message.ltNow !== undefined && message.ltNow !== false) {
obj.ltNow = message.ltNow;
}
if (message.gtNow !== undefined && message.gtNow !== false) {
obj.gtNow = message.gtNow;
}
if (message.within !== undefined) {
obj.within = Duration.toJSON(message.within);
}
return obj;
},
create(base) {
return TimestampRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseTimestampRules();
message.required = object.required ?? false;
message.const = object.const ?? undefined;
message.lt = object.lt ?? undefined;
message.lte = object.lte ?? undefined;
message.gt = object.gt ?? undefined;
message.gte = object.gte ?? undefined;
message.ltNow = object.ltNow ?? false;
message.gtNow = object.gtNow ?? false;
message.within = (object.within !== undefined && object.within !== null)
? Duration.fromPartial(object.within)
: undefined;
return message;
},
};
function bytesFromBase64(b64) {
return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
}
function base64FromBytes(arr) {
return globalThis.Buffer.from(arr).toString("base64");
}
function toTimestamp(date) {
const seconds = numberToLong(Math.trunc(date.getTime() / 1_000));
const nanos = (date.getTime() % 1_000) * 1_000_000;
return { seconds, nanos };
}
function fromTimestamp(t) {
let millis = (t.seconds.toNumber() || 0) * 1_000;
millis += (t.nanos || 0) / 1_000_000;
return new globalThis.Date(millis);
}
function fromJsonTimestamp(o) {
if (o instanceof globalThis.Date) {
return o;
}
else if (typeof o === "string") {
return new globalThis.Date(o);
}
else {
return fromTimestamp(Timestamp.fromJSON(o));
}
}
function numberToLong(number) {
return Long.fromNumber(number);
}
function isSet(value) {
return value !== null && value !== undefined;
}