@ragnaraven/zitadel-node-dual
Version:
Library for API access to ZITADEL with modern ES import syntax. Works everywhere - NestJS, Node.js, any TypeScript environment. No more require()!
1,488 lines • 148 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var validate_exports = {};
__export(validate_exports, {
AnyRules: () => AnyRules,
BoolRules: () => BoolRules,
BytesRules: () => BytesRules,
DoubleRules: () => DoubleRules,
DurationRules: () => DurationRules,
EnumRules: () => EnumRules,
FieldRules: () => FieldRules,
Fixed32Rules: () => Fixed32Rules,
Fixed64Rules: () => Fixed64Rules,
FloatRules: () => FloatRules,
Int32Rules: () => Int32Rules,
Int64Rules: () => Int64Rules,
KnownRegex: () => KnownRegex,
MapRules: () => MapRules,
MessageRules: () => MessageRules,
RepeatedRules: () => RepeatedRules,
SFixed32Rules: () => SFixed32Rules,
SFixed64Rules: () => SFixed64Rules,
SInt32Rules: () => SInt32Rules,
SInt64Rules: () => SInt64Rules,
StringRules: () => StringRules,
TimestampRules: () => TimestampRules,
UInt32Rules: () => UInt32Rules,
UInt64Rules: () => UInt64Rules,
knownRegexFromJSON: () => knownRegexFromJSON,
knownRegexToJSON: () => knownRegexToJSON,
protobufPackage: () => protobufPackage
});
module.exports = __toCommonJS(validate_exports);
var import_wire = require("@bufbuild/protobuf/wire");
var import_long = __toESM(require("long"));
var import_duration = require("../google/protobuf/duration.js");
var import_timestamp = require("../google/protobuf/timestamp.js");
const protobufPackage = "validate";
var KnownRegex = /* @__PURE__ */ ((KnownRegex2) => {
KnownRegex2[KnownRegex2["UNKNOWN"] = 0] = "UNKNOWN";
KnownRegex2[KnownRegex2["HTTP_HEADER_NAME"] = 1] = "HTTP_HEADER_NAME";
KnownRegex2[KnownRegex2["HTTP_HEADER_VALUE"] = 2] = "HTTP_HEADER_VALUE";
KnownRegex2[KnownRegex2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
return KnownRegex2;
})(KnownRegex || {});
function knownRegexFromJSON(object) {
switch (object) {
case 0:
case "UNKNOWN":
return 0 /* UNKNOWN */;
case 1:
case "HTTP_HEADER_NAME":
return 1 /* HTTP_HEADER_NAME */;
case 2:
case "HTTP_HEADER_VALUE":
return 2 /* HTTP_HEADER_VALUE */;
case -1:
case "UNRECOGNIZED":
default:
return -1 /* UNRECOGNIZED */;
}
}
function knownRegexToJSON(object) {
switch (object) {
case 0 /* UNKNOWN */:
return "UNKNOWN";
case 1 /* HTTP_HEADER_NAME */:
return "HTTP_HEADER_NAME";
case 2 /* HTTP_HEADER_VALUE */:
return "HTTP_HEADER_VALUE";
case -1 /* UNRECOGNIZED */:
default:
return "UNRECOGNIZED";
}
}
function createBaseFieldRules() {
return {
message: void 0,
float: void 0,
double: void 0,
int32: void 0,
int64: void 0,
uint32: void 0,
uint64: void 0,
sint32: void 0,
sint64: void 0,
fixed32: void 0,
fixed64: void 0,
sfixed32: void 0,
sfixed64: void 0,
bool: void 0,
string: void 0,
bytes: void 0,
enum: void 0,
repeated: void 0,
map: void 0,
any: void 0,
duration: void 0,
timestamp: void 0
};
}
const FieldRules = {
encode(message, writer = new import_wire.BinaryWriter()) {
if (message.message !== void 0) {
MessageRules.encode(message.message, writer.uint32(138).fork()).join();
}
if (message.float !== void 0) {
FloatRules.encode(message.float, writer.uint32(10).fork()).join();
}
if (message.double !== void 0) {
DoubleRules.encode(message.double, writer.uint32(18).fork()).join();
}
if (message.int32 !== void 0) {
Int32Rules.encode(message.int32, writer.uint32(26).fork()).join();
}
if (message.int64 !== void 0) {
Int64Rules.encode(message.int64, writer.uint32(34).fork()).join();
}
if (message.uint32 !== void 0) {
UInt32Rules.encode(message.uint32, writer.uint32(42).fork()).join();
}
if (message.uint64 !== void 0) {
UInt64Rules.encode(message.uint64, writer.uint32(50).fork()).join();
}
if (message.sint32 !== void 0) {
SInt32Rules.encode(message.sint32, writer.uint32(58).fork()).join();
}
if (message.sint64 !== void 0) {
SInt64Rules.encode(message.sint64, writer.uint32(66).fork()).join();
}
if (message.fixed32 !== void 0) {
Fixed32Rules.encode(message.fixed32, writer.uint32(74).fork()).join();
}
if (message.fixed64 !== void 0) {
Fixed64Rules.encode(message.fixed64, writer.uint32(82).fork()).join();
}
if (message.sfixed32 !== void 0) {
SFixed32Rules.encode(message.sfixed32, writer.uint32(90).fork()).join();
}
if (message.sfixed64 !== void 0) {
SFixed64Rules.encode(message.sfixed64, writer.uint32(98).fork()).join();
}
if (message.bool !== void 0) {
BoolRules.encode(message.bool, writer.uint32(106).fork()).join();
}
if (message.string !== void 0) {
StringRules.encode(message.string, writer.uint32(114).fork()).join();
}
if (message.bytes !== void 0) {
BytesRules.encode(message.bytes, writer.uint32(122).fork()).join();
}
if (message.enum !== void 0) {
EnumRules.encode(message.enum, writer.uint32(130).fork()).join();
}
if (message.repeated !== void 0) {
RepeatedRules.encode(message.repeated, writer.uint32(146).fork()).join();
}
if (message.map !== void 0) {
MapRules.encode(message.map, writer.uint32(154).fork()).join();
}
if (message.any !== void 0) {
AnyRules.encode(message.any, writer.uint32(162).fork()).join();
}
if (message.duration !== void 0) {
DurationRules.encode(message.duration, writer.uint32(170).fork()).join();
}
if (message.timestamp !== void 0) {
TimestampRules.encode(message.timestamp, writer.uint32(178).fork()).join();
}
return writer;
},
decode(input, length) {
const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
const end = length === void 0 ? 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) : void 0,
float: isSet(object.float) ? FloatRules.fromJSON(object.float) : void 0,
double: isSet(object.double) ? DoubleRules.fromJSON(object.double) : void 0,
int32: isSet(object.int32) ? Int32Rules.fromJSON(object.int32) : void 0,
int64: isSet(object.int64) ? Int64Rules.fromJSON(object.int64) : void 0,
uint32: isSet(object.uint32) ? UInt32Rules.fromJSON(object.uint32) : void 0,
uint64: isSet(object.uint64) ? UInt64Rules.fromJSON(object.uint64) : void 0,
sint32: isSet(object.sint32) ? SInt32Rules.fromJSON(object.sint32) : void 0,
sint64: isSet(object.sint64) ? SInt64Rules.fromJSON(object.sint64) : void 0,
fixed32: isSet(object.fixed32) ? Fixed32Rules.fromJSON(object.fixed32) : void 0,
fixed64: isSet(object.fixed64) ? Fixed64Rules.fromJSON(object.fixed64) : void 0,
sfixed32: isSet(object.sfixed32) ? SFixed32Rules.fromJSON(object.sfixed32) : void 0,
sfixed64: isSet(object.sfixed64) ? SFixed64Rules.fromJSON(object.sfixed64) : void 0,
bool: isSet(object.bool) ? BoolRules.fromJSON(object.bool) : void 0,
string: isSet(object.string) ? StringRules.fromJSON(object.string) : void 0,
bytes: isSet(object.bytes) ? BytesRules.fromJSON(object.bytes) : void 0,
enum: isSet(object.enum) ? EnumRules.fromJSON(object.enum) : void 0,
repeated: isSet(object.repeated) ? RepeatedRules.fromJSON(object.repeated) : void 0,
map: isSet(object.map) ? MapRules.fromJSON(object.map) : void 0,
any: isSet(object.any) ? AnyRules.fromJSON(object.any) : void 0,
duration: isSet(object.duration) ? DurationRules.fromJSON(object.duration) : void 0,
timestamp: isSet(object.timestamp) ? TimestampRules.fromJSON(object.timestamp) : void 0
};
},
toJSON(message) {
const obj = {};
if (message.message !== void 0) {
obj.message = MessageRules.toJSON(message.message);
}
if (message.float !== void 0) {
obj.float = FloatRules.toJSON(message.float);
}
if (message.double !== void 0) {
obj.double = DoubleRules.toJSON(message.double);
}
if (message.int32 !== void 0) {
obj.int32 = Int32Rules.toJSON(message.int32);
}
if (message.int64 !== void 0) {
obj.int64 = Int64Rules.toJSON(message.int64);
}
if (message.uint32 !== void 0) {
obj.uint32 = UInt32Rules.toJSON(message.uint32);
}
if (message.uint64 !== void 0) {
obj.uint64 = UInt64Rules.toJSON(message.uint64);
}
if (message.sint32 !== void 0) {
obj.sint32 = SInt32Rules.toJSON(message.sint32);
}
if (message.sint64 !== void 0) {
obj.sint64 = SInt64Rules.toJSON(message.sint64);
}
if (message.fixed32 !== void 0) {
obj.fixed32 = Fixed32Rules.toJSON(message.fixed32);
}
if (message.fixed64 !== void 0) {
obj.fixed64 = Fixed64Rules.toJSON(message.fixed64);
}
if (message.sfixed32 !== void 0) {
obj.sfixed32 = SFixed32Rules.toJSON(message.sfixed32);
}
if (message.sfixed64 !== void 0) {
obj.sfixed64 = SFixed64Rules.toJSON(message.sfixed64);
}
if (message.bool !== void 0) {
obj.bool = BoolRules.toJSON(message.bool);
}
if (message.string !== void 0) {
obj.string = StringRules.toJSON(message.string);
}
if (message.bytes !== void 0) {
obj.bytes = BytesRules.toJSON(message.bytes);
}
if (message.enum !== void 0) {
obj.enum = EnumRules.toJSON(message.enum);
}
if (message.repeated !== void 0) {
obj.repeated = RepeatedRules.toJSON(message.repeated);
}
if (message.map !== void 0) {
obj.map = MapRules.toJSON(message.map);
}
if (message.any !== void 0) {
obj.any = AnyRules.toJSON(message.any);
}
if (message.duration !== void 0) {
obj.duration = DurationRules.toJSON(message.duration);
}
if (message.timestamp !== void 0) {
obj.timestamp = TimestampRules.toJSON(message.timestamp);
}
return obj;
},
create(base) {
return FieldRules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseFieldRules();
message.message = object.message !== void 0 && object.message !== null ? MessageRules.fromPartial(object.message) : void 0;
message.float = object.float !== void 0 && object.float !== null ? FloatRules.fromPartial(object.float) : void 0;
message.double = object.double !== void 0 && object.double !== null ? DoubleRules.fromPartial(object.double) : void 0;
message.int32 = object.int32 !== void 0 && object.int32 !== null ? Int32Rules.fromPartial(object.int32) : void 0;
message.int64 = object.int64 !== void 0 && object.int64 !== null ? Int64Rules.fromPartial(object.int64) : void 0;
message.uint32 = object.uint32 !== void 0 && object.uint32 !== null ? UInt32Rules.fromPartial(object.uint32) : void 0;
message.uint64 = object.uint64 !== void 0 && object.uint64 !== null ? UInt64Rules.fromPartial(object.uint64) : void 0;
message.sint32 = object.sint32 !== void 0 && object.sint32 !== null ? SInt32Rules.fromPartial(object.sint32) : void 0;
message.sint64 = object.sint64 !== void 0 && object.sint64 !== null ? SInt64Rules.fromPartial(object.sint64) : void 0;
message.fixed32 = object.fixed32 !== void 0 && object.fixed32 !== null ? Fixed32Rules.fromPartial(object.fixed32) : void 0;
message.fixed64 = object.fixed64 !== void 0 && object.fixed64 !== null ? Fixed64Rules.fromPartial(object.fixed64) : void 0;
message.sfixed32 = object.sfixed32 !== void 0 && object.sfixed32 !== null ? SFixed32Rules.fromPartial(object.sfixed32) : void 0;
message.sfixed64 = object.sfixed64 !== void 0 && object.sfixed64 !== null ? SFixed64Rules.fromPartial(object.sfixed64) : void 0;
message.bool = object.bool !== void 0 && object.bool !== null ? BoolRules.fromPartial(object.bool) : void 0;
message.string = object.string !== void 0 && object.string !== null ? StringRules.fromPartial(object.string) : void 0;
message.bytes = object.bytes !== void 0 && object.bytes !== null ? BytesRules.fromPartial(object.bytes) : void 0;
message.enum = object.enum !== void 0 && object.enum !== null ? EnumRules.fromPartial(object.enum) : void 0;
message.repeated = object.repeated !== void 0 && object.repeated !== null ? RepeatedRules.fromPartial(object.repeated) : void 0;
message.map = object.map !== void 0 && object.map !== null ? MapRules.fromPartial(object.map) : void 0;
message.any = object.any !== void 0 && object.any !== null ? AnyRules.fromPartial(object.any) : void 0;
message.duration = object.duration !== void 0 && object.duration !== null ? DurationRules.fromPartial(object.duration) : void 0;
message.timestamp = object.timestamp !== void 0 && object.timestamp !== null ? TimestampRules.fromPartial(object.timestamp) : void 0;
return message;
}
};
function createBaseFloatRules() {
return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
const FloatRules = {
encode(message, writer = new import_wire.BinaryWriter()) {
if (message.const !== void 0 && message.const !== 0) {
writer.uint32(13).float(message.const);
}
if (message.lt !== void 0 && message.lt !== 0) {
writer.uint32(21).float(message.lt);
}
if (message.lte !== void 0 && message.lte !== 0) {
writer.uint32(29).float(message.lte);
}
if (message.gt !== void 0 && message.gt !== 0) {
writer.uint32(37).float(message.gt);
}
if (message.gte !== void 0 && 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 !== void 0 && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
const end = length === void 0 ? 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 !== void 0 && message.const !== 0) {
obj.const = message.const;
}
if (message.lt !== void 0 && message.lt !== 0) {
obj.lt = message.lt;
}
if (message.lte !== void 0 && message.lte !== 0) {
obj.lte = message.lte;
}
if (message.gt !== void 0 && message.gt !== 0) {
obj.gt = message.gt;
}
if (message.gte !== void 0 && 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 !== void 0 && 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 };
}
const DoubleRules = {
encode(message, writer = new import_wire.BinaryWriter()) {
if (message.const !== void 0 && message.const !== 0) {
writer.uint32(9).double(message.const);
}
if (message.lt !== void 0 && message.lt !== 0) {
writer.uint32(17).double(message.lt);
}
if (message.lte !== void 0 && message.lte !== 0) {
writer.uint32(25).double(message.lte);
}
if (message.gt !== void 0 && message.gt !== 0) {
writer.uint32(33).double(message.gt);
}
if (message.gte !== void 0 && 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 !== void 0 && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
const end = length === void 0 ? 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 !== void 0 && message.const !== 0) {
obj.const = message.const;
}
if (message.lt !== void 0 && message.lt !== 0) {
obj.lt = message.lt;
}
if (message.lte !== void 0 && message.lte !== 0) {
obj.lte = message.lte;
}
if (message.gt !== void 0 && message.gt !== 0) {
obj.gt = message.gt;
}
if (message.gte !== void 0 && 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 !== void 0 && 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 };
}
const Int32Rules = {
encode(message, writer = new import_wire.BinaryWriter()) {
if (message.const !== void 0 && message.const !== 0) {
writer.uint32(8).int32(message.const);
}
if (message.lt !== void 0 && message.lt !== 0) {
writer.uint32(16).int32(message.lt);
}
if (message.lte !== void 0 && message.lte !== 0) {
writer.uint32(24).int32(message.lte);
}
if (message.gt !== void 0 && message.gt !== 0) {
writer.uint32(32).int32(message.gt);
}
if (message.gte !== void 0 && 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 !== void 0 && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
const end = length === void 0 ? 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 !== void 0 && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.lt !== void 0 && message.lt !== 0) {
obj.lt = Math.round(message.lt);
}
if (message.lte !== void 0 && message.lte !== 0) {
obj.lte = Math.round(message.lte);
}
if (message.gt !== void 0 && message.gt !== 0) {
obj.gt = Math.round(message.gt);
}
if (message.gte !== void 0 && 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 !== void 0 && 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: import_long.default.ZERO,
lt: import_long.default.ZERO,
lte: import_long.default.ZERO,
gt: import_long.default.ZERO,
gte: import_long.default.ZERO,
in: [],
notIn: [],
ignoreEmpty: false
};
}
const Int64Rules = {
encode(message, writer = new import_wire.BinaryWriter()) {
if (message.const !== void 0 && !message.const.equals(import_long.default.ZERO)) {
writer.uint32(8).int64(message.const.toString());
}
if (message.lt !== void 0 && !message.lt.equals(import_long.default.ZERO)) {
writer.uint32(16).int64(message.lt.toString());
}
if (message.lte !== void 0 && !message.lte.equals(import_long.default.ZERO)) {
writer.uint32(24).int64(message.lte.toString());
}
if (message.gt !== void 0 && !message.gt.equals(import_long.default.ZERO)) {
writer.uint32(32).int64(message.gt.toString());
}
if (message.gte !== void 0 && !message.gte.equals(import_long.default.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 !== void 0 && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
const end = length === void 0 ? 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 = import_long.default.fromString(reader.int64().toString());
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lt = import_long.default.fromString(reader.int64().toString());
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = import_long.default.fromString(reader.int64().toString());
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = import_long.default.fromString(reader.int64().toString());
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.gte = import_long.default.fromString(reader.int64().toString());
continue;
}
case 6: {
if (tag === 48) {
message.in.push(import_long.default.fromString(reader.int64().toString()));
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(import_long.default.fromString(reader.int64().toString()));
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(import_long.default.fromString(reader.int64().toString()));
continue;
}
if (tag === 58) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.notIn.push(import_long.default.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) ? import_long.default.fromValue(object.const) : import_long.default.ZERO,
lt: isSet(object.lt) ? import_long.default.fromValue(object.lt) : import_long.default.ZERO,
lte: isSet(object.lte) ? import_long.default.fromValue(object.lte) : import_long.default.ZERO,
gt: isSet(object.gt) ? import_long.default.fromValue(object.gt) : import_long.default.ZERO,
gte: isSet(object.gte) ? import_long.default.fromValue(object.gte) : import_long.default.ZERO,
in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => import_long.default.fromValue(e)) : [],
notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => import_long.default.fromValue(e)) : [],
ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false
};
},
toJSON(message) {
const obj = {};
if (message.const !== void 0 && !message.const.equals(import_long.default.ZERO)) {
obj.const = (message.const || import_long.default.ZERO).toString();
}
if (message.lt !== void 0 && !message.lt.equals(import_long.default.ZERO)) {
obj.lt = (message.lt || import_long.default.ZERO).toString();
}
if (message.lte !== void 0 && !message.lte.equals(import_long.default.ZERO)) {
obj.lte = (message.lte || import_long.default.ZERO).toString();
}
if (message.gt !== void 0 && !message.gt.equals(import_long.default.ZERO)) {
obj.gt = (message.gt || import_long.default.ZERO).toString();
}
if (message.gte !== void 0 && !message.gte.equals(import_long.default.ZERO)) {
obj.gte = (message.gte || import_long.default.ZERO).toString();
}
if (message.in?.length) {
obj.in = message.in.map((e) => (e || import_long.default.ZERO).toString());
}
if (message.notIn?.length) {
obj.notIn = message.notIn.map((e) => (e || import_long.default.ZERO).toString());
}
if (message.ignoreEmpty !== void 0 && message.ignoreEmpty !== false) {
obj.ignoreEmpty = message.ignoreEmpty;
}
return obj;
},
create(base) {
return Int64Rules.fromPartial(base ?? {});
},
fromPartial(object) {
const message = createBaseInt64Rules();
message.const = object.const !== void 0 && object.const !== null ? import_long.default.fromValue(object.const) : import_long.default.ZERO;
message.lt = object.lt !== void 0 && object.lt !== null ? import_long.default.fromValue(object.lt) : import_long.default.ZERO;
message.lte = object.lte !== void 0 && object.lte !== null ? import_long.default.fromValue(object.lte) : import_long.default.ZERO;
message.gt = object.gt !== void 0 && object.gt !== null ? import_long.default.fromValue(object.gt) : import_long.default.ZERO;
message.gte = object.gte !== void 0 && object.gte !== null ? import_long.default.fromValue(object.gte) : import_long.default.ZERO;
message.in = object.in?.map((e) => import_long.default.fromValue(e)) || [];
message.notIn = object.notIn?.map((e) => import_long.default.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 };
}
const UInt32Rules = {
encode(message, writer = new import_wire.BinaryWriter()) {
if (message.const !== void 0 && message.const !== 0) {
writer.uint32(8).uint32(message.const);
}
if (message.lt !== void 0 && message.lt !== 0) {
writer.uint32(16).uint32(message.lt);
}
if (message.lte !== void 0 && message.lte !== 0) {
writer.uint32(24).uint32(message.lte);
}
if (message.gt !== void 0 && message.gt !== 0) {
writer.uint32(32).uint32(message.gt);
}
if (message.gte !== void 0 && 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 !== void 0 && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
const end = length === void 0 ? 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 !== void 0 && message.const !== 0) {
obj.const = Math.round(message.const);
}
if (message.lt !== void 0 && message.lt !== 0) {
obj.lt = Math.round(message.lt);
}
if (message.lte !== void 0 && message.lte !== 0) {
obj.lte = Math.round(message.lte);
}
if (message.gt !== void 0 && message.gt !== 0) {
obj.gt = Math.round(message.gt);
}
if (message.gte !== void 0 && 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 !== void 0 && 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: import_long.default.UZERO,
lt: import_long.default.UZERO,
lte: import_long.default.UZERO,
gt: import_long.default.UZERO,
gte: import_long.default.UZERO,
in: [],
notIn: [],
ignoreEmpty: false
};
}
const UInt64Rules = {
encode(message, writer = new import_wire.BinaryWriter()) {
if (message.const !== void 0 && !message.const.equals(import_long.default.UZERO)) {
writer.uint32(8).uint64(message.const.toString());
}
if (message.lt !== void 0 && !message.lt.equals(import_long.default.UZERO)) {
writer.uint32(16).uint64(message.lt.toString());
}
if (message.lte !== void 0 && !message.lte.equals(import_long.default.UZERO)) {
writer.uint32(24).uint64(message.lte.toString());
}
if (message.gt !== void 0 && !message.gt.equals(import_long.default.UZERO)) {
writer.uint32(32).uint64(message.gt.toString());
}
if (message.gte !== void 0 && !message.gte.equals(import_long.default.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 !== void 0 && message.ignoreEmpty !== false) {
writer.uint32(64).bool(message.ignoreEmpty);
}
return writer;
},
decode(input, length) {
const reader = input instanceof import_wire.BinaryReader ? input : new import_wire.BinaryReader(input);
const end = length === void 0 ? 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 = import_long.default.fromString(reader.uint64().toString(), true);
continue;
}
case 2: {
if (tag !== 16) {
break;
}
message.lt = import_long.default.fromString(reader.uint64().toString(), true);
continue;
}
case 3: {
if (tag !== 24) {
break;
}
message.lte = import_long.default.fromString(reader.uint64().toString(), true);
continue;
}
case 4: {
if (tag !== 32) {
break;
}
message.gt = import_long.default.fromString(reader.uint64().toString(), true);
continue;
}
case 5: {
if (tag !== 40) {
break;
}
message.gte = import_long.default.fromString(reader.uint64().toString(), true);
continue;
}
case 6: {
if (tag === 48) {
message.in.push(import_long.default.fromString(reader.uint64().toString(), true));
continue;
}
if (tag === 50) {
const end2 = reader.uint32() + reader.pos;
while (reader.pos < end2) {
message.in.push(import_long.default.fromString(reader.uint64().toString(), true));
}
continue;
}
break;
}
case 7: {
if (tag === 56) {
message.notIn.push(import_long.default.fromString(reader.uint64().toString(), true));
continue;
}
if (tag === 58) {
const end2 = reader.uint32