@primerouting/zitadel-node/dist/grpc/generated/validate/validate.js

Library for API access to ZITADEL. Provides compiled gRPC service clients and helpers for applications and service accounts. Support http2 self-hosted instances

"use strict";
// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// versions:
//   protoc-gen-ts_proto  v1.181.1
//   protoc               unknown
// source: validate/validate.proto
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TimestampRules = exports.DurationRules = exports.AnyRules = exports.MapRules = exports.RepeatedRules = exports.MessageRules = exports.EnumRules = exports.BytesRules = exports.StringRules = exports.BoolRules = exports.SFixed64Rules = exports.SFixed32Rules = exports.Fixed64Rules = exports.Fixed32Rules = exports.SInt64Rules = exports.SInt32Rules = exports.UInt64Rules = exports.UInt32Rules = exports.Int64Rules = exports.Int32Rules = exports.DoubleRules = exports.FloatRules = exports.FieldRules = exports.KnownRegex = exports.protobufPackage = void 0;
exports.knownRegexFromJSON = knownRegexFromJSON;
exports.knownRegexToJSON = knownRegexToJSON;
/* eslint-disable */
const long_1 = __importDefault(require("long"));
const minimal_1 = __importDefault(require("protobufjs/minimal"));
const duration_1 = require("../google/protobuf/duration");
const timestamp_1 = require("../google/protobuf/timestamp");
exports.protobufPackage = "validate";
/** WellKnownRegex contain some well-known patterns. */
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 || (exports.KnownRegex = KnownRegex = {}));
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;
    }
}
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,
    };
}
exports.FieldRules = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.message !== undefined) {
            exports.MessageRules.encode(message.message, writer.uint32(138).fork()).ldelim();
        }
        if (message.float !== undefined) {
            exports.FloatRules.encode(message.float, writer.uint32(10).fork()).ldelim();
        }
        if (message.double !== undefined) {
            exports.DoubleRules.encode(message.double, writer.uint32(18).fork()).ldelim();
        }
        if (message.int32 !== undefined) {
            exports.Int32Rules.encode(message.int32, writer.uint32(26).fork()).ldelim();
        }
        if (message.int64 !== undefined) {
            exports.Int64Rules.encode(message.int64, writer.uint32(34).fork()).ldelim();
        }
        if (message.uint32 !== undefined) {
            exports.UInt32Rules.encode(message.uint32, writer.uint32(42).fork()).ldelim();
        }
        if (message.uint64 !== undefined) {
            exports.UInt64Rules.encode(message.uint64, writer.uint32(50).fork()).ldelim();
        }
        if (message.sint32 !== undefined) {
            exports.SInt32Rules.encode(message.sint32, writer.uint32(58).fork()).ldelim();
        }
        if (message.sint64 !== undefined) {
            exports.SInt64Rules.encode(message.sint64, writer.uint32(66).fork()).ldelim();
        }
        if (message.fixed32 !== undefined) {
            exports.Fixed32Rules.encode(message.fixed32, writer.uint32(74).fork()).ldelim();
        }
        if (message.fixed64 !== undefined) {
            exports.Fixed64Rules.encode(message.fixed64, writer.uint32(82).fork()).ldelim();
        }
        if (message.sfixed32 !== undefined) {
            exports.SFixed32Rules.encode(message.sfixed32, writer.uint32(90).fork()).ldelim();
        }
        if (message.sfixed64 !== undefined) {
            exports.SFixed64Rules.encode(message.sfixed64, writer.uint32(98).fork()).ldelim();
        }
        if (message.bool !== undefined) {
            exports.BoolRules.encode(message.bool, writer.uint32(106).fork()).ldelim();
        }
        if (message.string !== undefined) {
            exports.StringRules.encode(message.string, writer.uint32(114).fork()).ldelim();
        }
        if (message.bytes !== undefined) {
            exports.BytesRules.encode(message.bytes, writer.uint32(122).fork()).ldelim();
        }
        if (message.enum !== undefined) {
            exports.EnumRules.encode(message.enum, writer.uint32(130).fork()).ldelim();
        }
        if (message.repeated !== undefined) {
            exports.RepeatedRules.encode(message.repeated, writer.uint32(146).fork()).ldelim();
        }
        if (message.map !== undefined) {
            exports.MapRules.encode(message.map, writer.uint32(154).fork()).ldelim();
        }
        if (message.any !== undefined) {
            exports.AnyRules.encode(message.any, writer.uint32(162).fork()).ldelim();
        }
        if (message.duration !== undefined) {
            exports.DurationRules.encode(message.duration, writer.uint32(170).fork()).ldelim();
        }
        if (message.timestamp !== undefined) {
            exports.TimestampRules.encode(message.timestamp, writer.uint32(178).fork()).ldelim();
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
        let 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 = exports.MessageRules.decode(reader, reader.uint32());
                    continue;
                case 1:
                    if (tag !== 10) {
                        break;
                    }
                    message.float = exports.FloatRules.decode(reader, reader.uint32());
                    continue;
                case 2:
                    if (tag !== 18) {
                        break;
                    }
                    message.double = exports.DoubleRules.decode(reader, reader.uint32());
                    continue;
                case 3:
                    if (tag !== 26) {
                        break;
                    }
                    message.int32 = exports.Int32Rules.decode(reader, reader.uint32());
                    continue;
                case 4:
                    if (tag !== 34) {
                        break;
                    }
                    message.int64 = exports.Int64Rules.decode(reader, reader.uint32());
                    continue;
                case 5:
                    if (tag !== 42) {
                        break;
                    }
                    message.uint32 = exports.UInt32Rules.decode(reader, reader.uint32());
                    continue;
                case 6:
                    if (tag !== 50) {
                        break;
                    }
                    message.uint64 = exports.UInt64Rules.decode(reader, reader.uint32());
                    continue;
                case 7:
                    if (tag !== 58) {
                        break;
                    }
                    message.sint32 = exports.SInt32Rules.decode(reader, reader.uint32());
                    continue;
                case 8:
                    if (tag !== 66) {
                        break;
                    }
                    message.sint64 = exports.SInt64Rules.decode(reader, reader.uint32());
                    continue;
                case 9:
                    if (tag !== 74) {
                        break;
                    }
                    message.fixed32 = exports.Fixed32Rules.decode(reader, reader.uint32());
                    continue;
                case 10:
                    if (tag !== 82) {
                        break;
                    }
                    message.fixed64 = exports.Fixed64Rules.decode(reader, reader.uint32());
                    continue;
                case 11:
                    if (tag !== 90) {
                        break;
                    }
                    message.sfixed32 = exports.SFixed32Rules.decode(reader, reader.uint32());
                    continue;
                case 12:
                    if (tag !== 98) {
                        break;
                    }
                    message.sfixed64 = exports.SFixed64Rules.decode(reader, reader.uint32());
                    continue;
                case 13:
                    if (tag !== 106) {
                        break;
                    }
                    message.bool = exports.BoolRules.decode(reader, reader.uint32());
                    continue;
                case 14:
                    if (tag !== 114) {
                        break;
                    }
                    message.string = exports.StringRules.decode(reader, reader.uint32());
                    continue;
                case 15:
                    if (tag !== 122) {
                        break;
                    }
                    message.bytes = exports.BytesRules.decode(reader, reader.uint32());
                    continue;
                case 16:
                    if (tag !== 130) {
                        break;
                    }
                    message.enum = exports.EnumRules.decode(reader, reader.uint32());
                    continue;
                case 18:
                    if (tag !== 146) {
                        break;
                    }
                    message.repeated = exports.RepeatedRules.decode(reader, reader.uint32());
                    continue;
                case 19:
                    if (tag !== 154) {
                        break;
                    }
                    message.map = exports.MapRules.decode(reader, reader.uint32());
                    continue;
                case 20:
                    if (tag !== 162) {
                        break;
                    }
                    message.any = exports.AnyRules.decode(reader, reader.uint32());
                    continue;
                case 21:
                    if (tag !== 170) {
                        break;
                    }
                    message.duration = exports.DurationRules.decode(reader, reader.uint32());
                    continue;
                case 22:
                    if (tag !== 178) {
                        break;
                    }
                    message.timestamp = exports.TimestampRules.decode(reader, reader.uint32());
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            message: isSet(object.message) ? exports.MessageRules.fromJSON(object.message) : undefined,
            float: isSet(object.float) ? exports.FloatRules.fromJSON(object.float) : undefined,
            double: isSet(object.double) ? exports.DoubleRules.fromJSON(object.double) : undefined,
            int32: isSet(object.int32) ? exports.Int32Rules.fromJSON(object.int32) : undefined,
            int64: isSet(object.int64) ? exports.Int64Rules.fromJSON(object.int64) : undefined,
            uint32: isSet(object.uint32) ? exports.UInt32Rules.fromJSON(object.uint32) : undefined,
            uint64: isSet(object.uint64) ? exports.UInt64Rules.fromJSON(object.uint64) : undefined,
            sint32: isSet(object.sint32) ? exports.SInt32Rules.fromJSON(object.sint32) : undefined,
            sint64: isSet(object.sint64) ? exports.SInt64Rules.fromJSON(object.sint64) : undefined,
            fixed32: isSet(object.fixed32) ? exports.Fixed32Rules.fromJSON(object.fixed32) : undefined,
            fixed64: isSet(object.fixed64) ? exports.Fixed64Rules.fromJSON(object.fixed64) : undefined,
            sfixed32: isSet(object.sfixed32) ? exports.SFixed32Rules.fromJSON(object.sfixed32) : undefined,
            sfixed64: isSet(object.sfixed64) ? exports.SFixed64Rules.fromJSON(object.sfixed64) : undefined,
            bool: isSet(object.bool) ? exports.BoolRules.fromJSON(object.bool) : undefined,
            string: isSet(object.string) ? exports.StringRules.fromJSON(object.string) : undefined,
            bytes: isSet(object.bytes) ? exports.BytesRules.fromJSON(object.bytes) : undefined,
            enum: isSet(object.enum) ? exports.EnumRules.fromJSON(object.enum) : undefined,
            repeated: isSet(object.repeated) ? exports.RepeatedRules.fromJSON(object.repeated) : undefined,
            map: isSet(object.map) ? exports.MapRules.fromJSON(object.map) : undefined,
            any: isSet(object.any) ? exports.AnyRules.fromJSON(object.any) : undefined,
            duration: isSet(object.duration) ? exports.DurationRules.fromJSON(object.duration) : undefined,
            timestamp: isSet(object.timestamp) ? exports.TimestampRules.fromJSON(object.timestamp) : undefined,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.message !== undefined) {
            obj.message = exports.MessageRules.toJSON(message.message);
        }
        if (message.float !== undefined) {
            obj.float = exports.FloatRules.toJSON(message.float);
        }
        if (message.double !== undefined) {
            obj.double = exports.DoubleRules.toJSON(message.double);
        }
        if (message.int32 !== undefined) {
            obj.int32 = exports.Int32Rules.toJSON(message.int32);
        }
        if (message.int64 !== undefined) {
            obj.int64 = exports.Int64Rules.toJSON(message.int64);
        }
        if (message.uint32 !== undefined) {
            obj.uint32 = exports.UInt32Rules.toJSON(message.uint32);
        }
        if (message.uint64 !== undefined) {
            obj.uint64 = exports.UInt64Rules.toJSON(message.uint64);
        }
        if (message.sint32 !== undefined) {
            obj.sint32 = exports.SInt32Rules.toJSON(message.sint32);
        }
        if (message.sint64 !== undefined) {
            obj.sint64 = exports.SInt64Rules.toJSON(message.sint64);
        }
        if (message.fixed32 !== undefined) {
            obj.fixed32 = exports.Fixed32Rules.toJSON(message.fixed32);
        }
        if (message.fixed64 !== undefined) {
            obj.fixed64 = exports.Fixed64Rules.toJSON(message.fixed64);
        }
        if (message.sfixed32 !== undefined) {
            obj.sfixed32 = exports.SFixed32Rules.toJSON(message.sfixed32);
        }
        if (message.sfixed64 !== undefined) {
            obj.sfixed64 = exports.SFixed64Rules.toJSON(message.sfixed64);
        }
        if (message.bool !== undefined) {
            obj.bool = exports.BoolRules.toJSON(message.bool);
        }
        if (message.string !== undefined) {
            obj.string = exports.StringRules.toJSON(message.string);
        }
        if (message.bytes !== undefined) {
            obj.bytes = exports.BytesRules.toJSON(message.bytes);
        }
        if (message.enum !== undefined) {
            obj.enum = exports.EnumRules.toJSON(message.enum);
        }
        if (message.repeated !== undefined) {
            obj.repeated = exports.RepeatedRules.toJSON(message.repeated);
        }
        if (message.map !== undefined) {
            obj.map = exports.MapRules.toJSON(message.map);
        }
        if (message.any !== undefined) {
            obj.any = exports.AnyRules.toJSON(message.any);
        }
        if (message.duration !== undefined) {
            obj.duration = exports.DurationRules.toJSON(message.duration);
        }
        if (message.timestamp !== undefined) {
            obj.timestamp = exports.TimestampRules.toJSON(message.timestamp);
        }
        return obj;
    },
    create(base) {
        return exports.FieldRules.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseFieldRules();
        message.message = (object.message !== undefined && object.message !== null)
            ? exports.MessageRules.fromPartial(object.message)
            : undefined;
        message.float = (object.float !== undefined && object.float !== null)
            ? exports.FloatRules.fromPartial(object.float)
            : undefined;
        message.double = (object.double !== undefined && object.double !== null)
            ? exports.DoubleRules.fromPartial(object.double)
            : undefined;
        message.int32 = (object.int32 !== undefined && object.int32 !== null)
            ? exports.Int32Rules.fromPartial(object.int32)
            : undefined;
        message.int64 = (object.int64 !== undefined && object.int64 !== null)
            ? exports.Int64Rules.fromPartial(object.int64)
            : undefined;
        message.uint32 = (object.uint32 !== undefined && object.uint32 !== null)
            ? exports.UInt32Rules.fromPartial(object.uint32)
            : undefined;
        message.uint64 = (object.uint64 !== undefined && object.uint64 !== null)
            ? exports.UInt64Rules.fromPartial(object.uint64)
            : undefined;
        message.sint32 = (object.sint32 !== undefined && object.sint32 !== null)
            ? exports.SInt32Rules.fromPartial(object.sint32)
            : undefined;
        message.sint64 = (object.sint64 !== undefined && object.sint64 !== null)
            ? exports.SInt64Rules.fromPartial(object.sint64)
            : undefined;
        message.fixed32 = (object.fixed32 !== undefined && object.fixed32 !== null)
            ? exports.Fixed32Rules.fromPartial(object.fixed32)
            : undefined;
        message.fixed64 = (object.fixed64 !== undefined && object.fixed64 !== null)
            ? exports.Fixed64Rules.fromPartial(object.fixed64)
            : undefined;
        message.sfixed32 = (object.sfixed32 !== undefined && object.sfixed32 !== null)
            ? exports.SFixed32Rules.fromPartial(object.sfixed32)
            : undefined;
        message.sfixed64 = (object.sfixed64 !== undefined && object.sfixed64 !== null)
            ? exports.SFixed64Rules.fromPartial(object.sfixed64)
            : undefined;
        message.bool = (object.bool !== undefined && object.bool !== null) ? exports.BoolRules.fromPartial(object.bool) : undefined;
        message.string = (object.string !== undefined && object.string !== null)
            ? exports.StringRules.fromPartial(object.string)
            : undefined;
        message.bytes = (object.bytes !== undefined && object.bytes !== null)
            ? exports.BytesRules.fromPartial(object.bytes)
            : undefined;
        message.enum = (object.enum !== undefined && object.enum !== null) ? exports.EnumRules.fromPartial(object.enum) : undefined;
        message.repeated = (object.repeated !== undefined && object.repeated !== null)
            ? exports.RepeatedRules.fromPartial(object.repeated)
            : undefined;
        message.map = (object.map !== undefined && object.map !== null) ? exports.MapRules.fromPartial(object.map) : undefined;
        message.any = (object.any !== undefined && object.any !== null) ? exports.AnyRules.fromPartial(object.any) : undefined;
        message.duration = (object.duration !== undefined && object.duration !== null)
            ? exports.DurationRules.fromPartial(object.duration)
            : undefined;
        message.timestamp = (object.timestamp !== undefined && object.timestamp !== null)
            ? exports.TimestampRules.fromPartial(object.timestamp)
            : undefined;
        return message;
    },
};
function createBaseFloatRules() {
    return { const: 0, lt: 0, lte: 0, gt: 0, gte: 0, in: [], notIn: [], ignoreEmpty: false };
}
exports.FloatRules = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        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.ldelim();
        writer.uint32(58).fork();
        for (const v of message.notIn) {
            writer.float(v);
        }
        writer.ldelim();
        if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
            writer.uint32(64).bool(message.ignoreEmpty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
        let 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.skipType(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 exports.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 };
}
exports.DoubleRules = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        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.ldelim();
        writer.uint32(58).fork();
        for (const v of message.notIn) {
            writer.double(v);
        }
        writer.ldelim();
        if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
            writer.uint32(64).bool(message.ignoreEmpty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
        let 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.skipType(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 exports.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 };
}
exports.Int32Rules = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        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.ldelim();
        writer.uint32(58).fork();
        for (const v of message.notIn) {
            writer.int32(v);
        }
        writer.ldelim();
        if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
            writer.uint32(64).bool(message.ignoreEmpty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
        let 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.skipType(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 exports.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_1.default.ZERO,
        lt: long_1.default.ZERO,
        lte: long_1.default.ZERO,
        gt: long_1.default.ZERO,
        gte: long_1.default.ZERO,
        in: [],
        notIn: [],
        ignoreEmpty: false,
    };
}
exports.Int64Rules = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        if (message.const !== undefined && !message.const.equals(long_1.default.ZERO)) {
            writer.uint32(8).int64(message.const);
        }
        if (message.lt !== undefined && !message.lt.equals(long_1.default.ZERO)) {
            writer.uint32(16).int64(message.lt);
        }
        if (message.lte !== undefined && !message.lte.equals(long_1.default.ZERO)) {
            writer.uint32(24).int64(message.lte);
        }
        if (message.gt !== undefined && !message.gt.equals(long_1.default.ZERO)) {
            writer.uint32(32).int64(message.gt);
        }
        if (message.gte !== undefined && !message.gte.equals(long_1.default.ZERO)) {
            writer.uint32(40).int64(message.gte);
        }
        writer.uint32(50).fork();
        for (const v of message.in) {
            writer.int64(v);
        }
        writer.ldelim();
        writer.uint32(58).fork();
        for (const v of message.notIn) {
            writer.int64(v);
        }
        writer.ldelim();
        if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
            writer.uint32(64).bool(message.ignoreEmpty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
        let end = length === undefined ? reader.len : reader.pos + length;
        const message = createBaseInt64Rules();
        while (reader.pos < end) {
            const tag = reader.uint32();
            switch (tag >>> 3) {
                case 1:
                    if (tag !== 8) {
                        break;
                    }
                    message.const = reader.int64();
                    continue;
                case 2:
                    if (tag !== 16) {
                        break;
                    }
                    message.lt = reader.int64();
                    continue;
                case 3:
                    if (tag !== 24) {
                        break;
                    }
                    message.lte = reader.int64();
                    continue;
                case 4:
                    if (tag !== 32) {
                        break;
                    }
                    message.gt = reader.int64();
                    continue;
                case 5:
                    if (tag !== 40) {
                        break;
                    }
                    message.gte = reader.int64();
                    continue;
                case 6:
                    if (tag === 48) {
                        message.in.push(reader.int64());
                        continue;
                    }
                    if (tag === 50) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.in.push(reader.int64());
                        }
                        continue;
                    }
                    break;
                case 7:
                    if (tag === 56) {
                        message.notIn.push(reader.int64());
                        continue;
                    }
                    if (tag === 58) {
                        const end2 = reader.uint32() + reader.pos;
                        while (reader.pos < end2) {
                            message.notIn.push(reader.int64());
                        }
                        continue;
                    }
                    break;
                case 8:
                    if (tag !== 64) {
                        break;
                    }
                    message.ignoreEmpty = reader.bool();
                    continue;
            }
            if ((tag & 7) === 4 || tag === 0) {
                break;
            }
            reader.skipType(tag & 7);
        }
        return message;
    },
    fromJSON(object) {
        return {
            const: isSet(object.const) ? long_1.default.fromValue(object.const) : long_1.default.ZERO,
            lt: isSet(object.lt) ? long_1.default.fromValue(object.lt) : long_1.default.ZERO,
            lte: isSet(object.lte) ? long_1.default.fromValue(object.lte) : long_1.default.ZERO,
            gt: isSet(object.gt) ? long_1.default.fromValue(object.gt) : long_1.default.ZERO,
            gte: isSet(object.gte) ? long_1.default.fromValue(object.gte) : long_1.default.ZERO,
            in: globalThis.Array.isArray(object?.in) ? object.in.map((e) => long_1.default.fromValue(e)) : [],
            notIn: globalThis.Array.isArray(object?.notIn) ? object.notIn.map((e) => long_1.default.fromValue(e)) : [],
            ignoreEmpty: isSet(object.ignoreEmpty) ? globalThis.Boolean(object.ignoreEmpty) : false,
        };
    },
    toJSON(message) {
        const obj = {};
        if (message.const !== undefined && !message.const.equals(long_1.default.ZERO)) {
            obj.const = (message.const || long_1.default.ZERO).toString();
        }
        if (message.lt !== undefined && !message.lt.equals(long_1.default.ZERO)) {
            obj.lt = (message.lt || long_1.default.ZERO).toString();
        }
        if (message.lte !== undefined && !message.lte.equals(long_1.default.ZERO)) {
            obj.lte = (message.lte || long_1.default.ZERO).toString();
        }
        if (message.gt !== undefined && !message.gt.equals(long_1.default.ZERO)) {
            obj.gt = (message.gt || long_1.default.ZERO).toString();
        }
        if (message.gte !== undefined && !message.gte.equals(long_1.default.ZERO)) {
            obj.gte = (message.gte || long_1.default.ZERO).toString();
        }
        if (message.in?.length) {
            obj.in = message.in.map((e) => (e || long_1.default.ZERO).toString());
        }
        if (message.notIn?.length) {
            obj.notIn = message.notIn.map((e) => (e || long_1.default.ZERO).toString());
        }
        if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
            obj.ignoreEmpty = message.ignoreEmpty;
        }
        return obj;
    },
    create(base) {
        return exports.Int64Rules.fromPartial(base ?? {});
    },
    fromPartial(object) {
        const message = createBaseInt64Rules();
        message.const = (object.const !== undefined && object.const !== null) ? long_1.default.fromValue(object.const) : long_1.default.ZERO;
        message.lt = (object.lt !== undefined && object.lt !== null) ? long_1.default.fromValue(object.lt) : long_1.default.ZERO;
        message.lte = (object.lte !== undefined && object.lte !== null) ? long_1.default.fromValue(object.lte) : long_1.default.ZERO;
        message.gt = (object.gt !== undefined && object.gt !== null) ? long_1.default.fromValue(object.gt) : long_1.default.ZERO;
        message.gte = (object.gte !== undefined && object.gte !== null) ? long_1.default.fromValue(object.gte) : long_1.default.ZERO;
        message.in = object.in?.map((e) => long_1.default.fromValue(e)) || [];
        message.notIn = object.notIn?.map((e) => long_1.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 };
}
exports.UInt32Rules = {
    encode(message, writer = minimal_1.default.Writer.create()) {
        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.ldelim();
        writer.uint32(58).fork();
        for (const v of message.notIn) {
            writer.uint32(v);
        }
        writer.ldelim();
        if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
            writer.uint32(64).bool(message.ignoreEmpty);
        }
        return writer;
    },
    decode(input, length) {
        const reader = input instanceof minimal_1.default.Reader ? input : minimal_1.default.Reader.create(input);
        let 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;