@zitadel/node/dist/api/generated/validate/validate.js

Library for API access to ZITADEL. Provides compiled gRPC service clients and helpers for applications and service accounts.

// 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) {