@fatehan/tsrp 1.6.20 → 1.6.21

package/dist/fatehan/utils/buf/validate/validate.js

@@ -0,0 +1,4248 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.6
+//   protoc               v7.34.1
+// source: utils/buf/validate/validate.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import Long from "long";
+import { Duration } from "../../../google/protobuf/duration";
+import { FieldMask } from "../../../google/protobuf/field_mask";
+import { Timestamp } from "../../../google/protobuf/timestamp";
+export const protobufPackage = "buf.validate";
+/**
+ * Specifies how `FieldRules.ignore` behaves, depending on the field's value, and
+ * whether the field tracks presence.
+ */
+export var Ignore;
+(function (Ignore) {
+    /**
+     * IGNORE_UNSPECIFIED - Ignore rules if the field tracks presence and is unset. This is the default
+     * behavior.
+     *
+     * In proto3, only message fields, members of a Protobuf `oneof`, and fields
+     * with the `optional` label track presence. Consequently, the following fields
+     * are always validated, whether a value is set or not:
+     *
+     * ```proto
+     * syntax="proto3";
+     *
+     * message RulesApply {
+     *   string email = 1 [
+     *     (buf.validate.field).string.email = true
+     *   ];
+     *   int32 age = 2 [
+     *     (buf.validate.field).int32.gt = 0
+     *   ];
+     *   repeated string labels = 3 [
+     *     (buf.validate.field).repeated.min_items = 1
+     *   ];
+     * }
+     * ```
+     *
+     * In contrast, the following fields track presence, and are only validated if
+     * a value is set:
+     *
+     * ```proto
+     * syntax="proto3";
+     *
+     * message RulesApplyIfSet {
+     *   optional string email = 1 [
+     *     (buf.validate.field).string.email = true
+     *   ];
+     *   oneof ref {
+     *     string reference = 2 [
+     *       (buf.validate.field).string.uuid = true
+     *     ];
+     *     string name = 3 [
+     *       (buf.validate.field).string.min_len = 4
+     *     ];
+     *   }
+     *   SomeMessage msg = 4 [
+     *     (buf.validate.field).cel = {/* ... * /}
+     *   ];
+     * }
+     * ```
+     *
+     * To ensure that such a field is set, add the `required` rule.
+     *
+     * To learn which fields track presence, see the
+     * [Field Presence cheat sheet](https://protobuf.dev/programming-guides/field_presence/#cheat).
+     */
+    Ignore[Ignore["IGNORE_UNSPECIFIED"] = 0] = "IGNORE_UNSPECIFIED";
+    /**
+     * IGNORE_IF_ZERO_VALUE - Ignore rules if the field is unset, or set to the zero value.
+     *
+     * The zero value depends on the field type:
+     * - For strings, the zero value is the empty string.
+     * - For bytes, the zero value is empty bytes.
+     * - For bool, the zero value is false.
+     * - For numeric types, the zero value is zero.
+     * - For enums, the zero value is the first defined enum value.
+     * - For repeated fields, the zero is an empty list.
+     * - For map fields, the zero is an empty map.
+     * - For message fields, absence of the message (typically a null-value) is considered zero value.
+     *
+     * For fields that track presence (e.g. adding the `optional` label in proto3),
+     * this a no-op and behavior is the same as the default `IGNORE_UNSPECIFIED`.
+     */
+    Ignore[Ignore["IGNORE_IF_ZERO_VALUE"] = 1] = "IGNORE_IF_ZERO_VALUE";
+    /**
+     * IGNORE_ALWAYS - Always ignore rules, including the `required` rule.
+     *
+     * This is useful for ignoring the rules of a referenced message, or to
+     * temporarily ignore rules during development.
+     *
+     * ```proto
+     * message MyMessage {
+     *   // The field's rules will always be ignored, including any validations
+     *   // on value's fields.
+     *   MyOtherMessage value = 1 [
+     *     (buf.validate.field).ignore = IGNORE_ALWAYS
+     *   ];
+     * }
+     * ```
+     */
+    Ignore[Ignore["IGNORE_ALWAYS"] = 3] = "IGNORE_ALWAYS";
+    Ignore[Ignore["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(Ignore || (Ignore = {}));
+/** KnownRegex contains some well-known patterns. */
+export var KnownRegex;
+(function (KnownRegex) {
+    KnownRegex[KnownRegex["KNOWN_REGEX_UNSPECIFIED"] = 0] = "KNOWN_REGEX_UNSPECIFIED";
+    /** KNOWN_REGEX_HTTP_HEADER_NAME - HTTP header name as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2). */
+    KnownRegex[KnownRegex["KNOWN_REGEX_HTTP_HEADER_NAME"] = 1] = "KNOWN_REGEX_HTTP_HEADER_NAME";
+    /** KNOWN_REGEX_HTTP_HEADER_VALUE - HTTP header value as defined by [RFC 7230](https://datatracker.ietf.org/doc/html/rfc7230#section-3.2.4). */
+    KnownRegex[KnownRegex["KNOWN_REGEX_HTTP_HEADER_VALUE"] = 2] = "KNOWN_REGEX_HTTP_HEADER_VALUE";
+    KnownRegex[KnownRegex["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(KnownRegex || (KnownRegex = {}));
+function createBaseRule() {
+    return { id: "", message: "", expression: "" };
+}
+export const Rule = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.id !== undefined && message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message.message !== undefined && message.message !== "") {
+            writer.uint32(18).string(message.message);
+        }
+        if (message.expression !== undefined && message.expression !== "") {
+            writer.uint32(26).string(message.expression);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.id = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.message = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.expression = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return Rule.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRule();
+        message.id = object.id ?? "";
+        message.message = object.message ?? "";
+        message.expression = object.expression ?? "";
+        return message;
+    },
+};
+function createBaseMessageRules() {
+    return { celExpression: [], cel: [], oneof: [] };
+}
+export const MessageRules = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.celExpression) {
+            writer.uint32(42).string(v);
+        }
+        for (const v of message.cel) {
+            Rule.encode(v, writer.uint32(26).fork()).join();
+        }
+        for (const v of message.oneof) {
+            MessageOneofRule.encode(v, writer.uint32(34).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 = createBaseMessageRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.celExpression.push(reader.string());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.cel.push(Rule.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.oneof.push(MessageOneofRule.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return MessageRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseMessageRules();
+        message.celExpression = object.celExpression?.map((e) => e) || [];
+        message.cel = object.cel?.map((e) => Rule.fromPartial(e)) || [];
+        message.oneof = object.oneof?.map((e) => MessageOneofRule.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseMessageOneofRule() {
+    return { fields: [], required: false };
+}
+export const MessageOneofRule = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.fields) {
+            writer.uint32(10).string(v);
+        }
+        if (message.required !== undefined && message.required !== false) {
+            writer.uint32(16).bool(message.required);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseMessageOneofRule();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fields.push(reader.string());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.required = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return MessageOneofRule.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseMessageOneofRule();
+        message.fields = object.fields?.map((e) => e) || [];
+        message.required = object.required ?? false;
+        return message;
+    },
+};
+function createBaseOneofRules() {
+    return { required: false };
+}
+export const OneofRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.required !== undefined && message.required !== false) {
+            writer.uint32(8).bool(message.required);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOneofRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.required = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return OneofRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseOneofRules();
+        message.required = object.required ?? false;
+        return message;
+    },
+};
+function createBaseFieldRules() {
+    return {
+        celExpression: [],
+        cel: [],
+        required: false,
+        ignore: 0,
+        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,
+        fieldMask: undefined,
+        timestamp: undefined,
+    };
+}
+export const FieldRules = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.celExpression) {
+            writer.uint32(234).string(v);
+        }
+        for (const v of message.cel) {
+            Rule.encode(v, writer.uint32(186).fork()).join();
+        }
+        if (message.required !== undefined && message.required !== false) {
+            writer.uint32(200).bool(message.required);
+        }
+        if (message.ignore !== undefined && message.ignore !== 0) {
+            writer.uint32(216).int32(message.ignore);
+        }
+        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.fieldMask !== undefined) {
+            FieldMaskRules.encode(message.fieldMask, writer.uint32(226).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 29: {
+                    if (tag !== 234) {
+                        break;
+                    }
+                    message.celExpression.push(reader.string());
+                    continue;
+                }
+                case 23: {
+                    if (tag !== 186) {
+                        break;
+                    }
+                    message.cel.push(Rule.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 25: {
+                    if (tag !== 200) {
+                        break;
+                    }
+                    message.required = reader.bool();
+                    continue;
+                }
+                case 27: {
+                    if (tag !== 216) {
+                        break;
+                    }
+                    message.ignore = reader.int32();
+                    continue;
+                }
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.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 28: {
+                    if (tag !== 226) {
+                        break;
+                    }
+                    message.fieldMask = FieldMaskRules.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;
+    },
+    create(base) {
+        return FieldRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFieldRules();
+        message.celExpression = object.celExpression?.map((e) => e) || [];
+        message.cel = object.cel?.map((e) => Rule.fromPartial(e)) || [];
+        message.required = object.required ?? false;
+        message.ignore = object.ignore ?? 0;
+        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.fieldMask = (object.fieldMask !== undefined && object.fieldMask !== null)
+            ? FieldMaskRules.fromPartial(object.fieldMask)
+            : undefined;
+        message.timestamp = (object.timestamp !== undefined && object.timestamp !== null)
+            ? TimestampRules.fromPartial(object.timestamp)
+            : undefined;
+        return message;
+    },
+};
+function createBasePredefinedRules() {
+    return { cel: [] };
+}
+export const PredefinedRules = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.cel) {
+            Rule.encode(v, writer.uint32(10).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 = createBasePredefinedRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.cel.push(Rule.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return PredefinedRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBasePredefinedRules();
+        message.cel = object.cel?.map((e) => Rule.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseFloatRules() {
+    return {
+        const: 0,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        finite: false,
+        example: [],
+    };
+}
+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) {
+            writer.uint32(21).float(message.lt);
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(29).float(message.lte);
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(37).float(message.gt);
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(45).float(message.gte);
+        }
+        for (const v of message.in) {
+            writer.uint32(53).float(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(61).float(v);
+        }
+        if (message.finite !== undefined && message.finite !== false) {
+            writer.uint32(64).bool(message.finite);
+        }
+        for (const v of message.example) {
+            writer.uint32(77).float(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = 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.finite = reader.bool();
+                    continue;
+                }
+                case 9: {
+                    if (tag === 77) {
+                        message.example.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 74) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return FloatRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFloatRules();
+        message.const = object.const ?? 0;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.finite = object.finite ?? false;
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseDoubleRules() {
+    return {
+        const: 0,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        finite: false,
+        example: [],
+    };
+}
+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) {
+            writer.uint32(17).double(message.lt);
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(25).double(message.lte);
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(33).double(message.gt);
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(41).double(message.gte);
+        }
+        for (const v of message.in) {
+            writer.uint32(49).double(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(57).double(v);
+        }
+        if (message.finite !== undefined && message.finite !== false) {
+            writer.uint32(64).bool(message.finite);
+        }
+        for (const v of message.example) {
+            writer.uint32(73).double(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = 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.finite = reader.bool();
+                    continue;
+                }
+                case 9: {
+                    if (tag === 73) {
+                        message.example.push(reader.double());
+                        continue;
+                    }
+                    if (tag === 74) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.double());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return DoubleRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDoubleRules();
+        message.const = object.const ?? 0;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.finite = object.finite ?? false;
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseInt32Rules() {
+    return { const: 0, lt: undefined, lte: undefined, gt: undefined, gte: undefined, in: [], notIn: [], example: [] };
+}
+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) {
+            writer.uint32(16).int32(message.lt);
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(24).int32(message.lte);
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(32).int32(message.gt);
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(40).int32(message.gte);
+        }
+        for (const v of message.in) {
+            writer.uint32(48).int32(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(56).int32(v);
+        }
+        for (const v of message.example) {
+            writer.uint32(64).int32(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = 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) {
+                        message.example.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return Int32Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseInt32Rules();
+        message.const = object.const ?? 0;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseInt64Rules() {
+    return {
+        const: Long.ZERO,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        example: [],
+    };
+}
+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) {
+            writer.uint32(16).int64(message.lt.toString());
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(24).int64(message.lte.toString());
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(32).int64(message.gt.toString());
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(40).int64(message.gte.toString());
+        }
+        for (const v of message.in) {
+            writer.uint32(48).int64(v.toString());
+        }
+        for (const v of message.notIn) {
+            writer.uint32(56).int64(v.toString());
+        }
+        for (const v of message.example) {
+            writer.uint32(72).int64(v.toString());
+        }
+        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 9: {
+                    if (tag === 72) {
+                        message.example.push(Long.fromString(reader.int64().toString()));
+                        continue;
+                    }
+                    if (tag === 74) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(Long.fromString(reader.int64().toString()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    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) : undefined;
+        message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : undefined;
+        message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : undefined;
+        message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : undefined;
+        message.in = object.in?.map((e) => Long.fromValue(e)) || [];
+        message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
+        message.example = object.example?.map((e) => Long.fromValue(e)) || [];
+        return message;
+    },
+};
+function createBaseUInt32Rules() {
+    return { const: 0, lt: undefined, lte: undefined, gt: undefined, gte: undefined, in: [], notIn: [], example: [] };
+}
+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) {
+            writer.uint32(16).uint32(message.lt);
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(24).uint32(message.lte);
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(32).uint32(message.gt);
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(40).uint32(message.gte);
+        }
+        for (const v of message.in) {
+            writer.uint32(48).uint32(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(56).uint32(v);
+        }
+        for (const v of message.example) {
+            writer.uint32(64).uint32(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseUInt32Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.const = reader.uint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.lt = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.lte = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.gt = reader.uint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.gte = reader.uint32();
+                    continue;
+                }
+                case 6: {
+                    if (tag === 48) {
+                        message.in.push(reader.uint32());
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 56) {
+                        message.notIn.push(reader.uint32());
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 64) {
+                        message.example.push(reader.uint32());
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.uint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return UInt32Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseUInt32Rules();
+        message.const = object.const ?? 0;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseUInt64Rules() {
+    return {
+        const: Long.UZERO,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        example: [],
+    };
+}
+export const UInt64Rules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && !message.const.equals(Long.UZERO)) {
+            writer.uint32(8).uint64(message.const.toString());
+        }
+        if (message.lt !== undefined) {
+            writer.uint32(16).uint64(message.lt.toString());
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(24).uint64(message.lte.toString());
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(32).uint64(message.gt.toString());
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(40).uint64(message.gte.toString());
+        }
+        for (const v of message.in) {
+            writer.uint32(48).uint64(v.toString());
+        }
+        for (const v of message.notIn) {
+            writer.uint32(56).uint64(v.toString());
+        }
+        for (const v of message.example) {
+            writer.uint32(64).uint64(v.toString());
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseUInt64Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.const = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.lt = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.lte = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.gt = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.gte = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 6: {
+                    if (tag === 48) {
+                        message.in.push(Long.fromString(reader.uint64().toString(), true));
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(Long.fromString(reader.uint64().toString(), true));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 56) {
+                        message.notIn.push(Long.fromString(reader.uint64().toString(), true));
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(Long.fromString(reader.uint64().toString(), true));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 64) {
+                        message.example.push(Long.fromString(reader.uint64().toString(), true));
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(Long.fromString(reader.uint64().toString(), true));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return UInt64Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseUInt64Rules();
+        message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.UZERO;
+        message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : undefined;
+        message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : undefined;
+        message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : undefined;
+        message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : undefined;
+        message.in = object.in?.map((e) => Long.fromValue(e)) || [];
+        message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
+        message.example = object.example?.map((e) => Long.fromValue(e)) || [];
+        return message;
+    },
+};
+function createBaseSInt32Rules() {
+    return { const: 0, lt: undefined, lte: undefined, gt: undefined, gte: undefined, in: [], notIn: [], example: [] };
+}
+export const SInt32Rules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && message.const !== 0) {
+            writer.uint32(8).sint32(message.const);
+        }
+        if (message.lt !== undefined) {
+            writer.uint32(16).sint32(message.lt);
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(24).sint32(message.lte);
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(32).sint32(message.gt);
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(40).sint32(message.gte);
+        }
+        for (const v of message.in) {
+            writer.uint32(48).sint32(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(56).sint32(v);
+        }
+        for (const v of message.example) {
+            writer.uint32(64).sint32(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSInt32Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.const = reader.sint32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.lt = reader.sint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.lte = reader.sint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.gt = reader.sint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.gte = reader.sint32();
+                    continue;
+                }
+                case 6: {
+                    if (tag === 48) {
+                        message.in.push(reader.sint32());
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(reader.sint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 56) {
+                        message.notIn.push(reader.sint32());
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(reader.sint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 64) {
+                        message.example.push(reader.sint32());
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.sint32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return SInt32Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSInt32Rules();
+        message.const = object.const ?? 0;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseSInt64Rules() {
+    return {
+        const: Long.ZERO,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        example: [],
+    };
+}
+export const SInt64Rules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
+            writer.uint32(8).sint64(message.const.toString());
+        }
+        if (message.lt !== undefined) {
+            writer.uint32(16).sint64(message.lt.toString());
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(24).sint64(message.lte.toString());
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(32).sint64(message.gt.toString());
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(40).sint64(message.gte.toString());
+        }
+        for (const v of message.in) {
+            writer.uint32(48).sint64(v.toString());
+        }
+        for (const v of message.notIn) {
+            writer.uint32(56).sint64(v.toString());
+        }
+        for (const v of message.example) {
+            writer.uint32(64).sint64(v.toString());
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSInt64Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.const = Long.fromString(reader.sint64().toString());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.lt = Long.fromString(reader.sint64().toString());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.lte = Long.fromString(reader.sint64().toString());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.gt = Long.fromString(reader.sint64().toString());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.gte = Long.fromString(reader.sint64().toString());
+                    continue;
+                }
+                case 6: {
+                    if (tag === 48) {
+                        message.in.push(Long.fromString(reader.sint64().toString()));
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(Long.fromString(reader.sint64().toString()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 56) {
+                        message.notIn.push(Long.fromString(reader.sint64().toString()));
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(Long.fromString(reader.sint64().toString()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 64) {
+                        message.example.push(Long.fromString(reader.sint64().toString()));
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(Long.fromString(reader.sint64().toString()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return SInt64Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSInt64Rules();
+        message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.ZERO;
+        message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : undefined;
+        message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : undefined;
+        message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : undefined;
+        message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : undefined;
+        message.in = object.in?.map((e) => Long.fromValue(e)) || [];
+        message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
+        message.example = object.example?.map((e) => Long.fromValue(e)) || [];
+        return message;
+    },
+};
+function createBaseFixed32Rules() {
+    return { const: 0, lt: undefined, lte: undefined, gt: undefined, gte: undefined, in: [], notIn: [], example: [] };
+}
+export const Fixed32Rules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && message.const !== 0) {
+            writer.uint32(13).fixed32(message.const);
+        }
+        if (message.lt !== undefined) {
+            writer.uint32(21).fixed32(message.lt);
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(29).fixed32(message.lte);
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(37).fixed32(message.gt);
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(45).fixed32(message.gte);
+        }
+        for (const v of message.in) {
+            writer.uint32(53).fixed32(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(61).fixed32(v);
+        }
+        for (const v of message.example) {
+            writer.uint32(69).fixed32(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFixed32Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.const = reader.fixed32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.lt = reader.fixed32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.lte = reader.fixed32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 37) {
+                        break;
+                    }
+                    message.gt = reader.fixed32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 45) {
+                        break;
+                    }
+                    message.gte = reader.fixed32();
+                    continue;
+                }
+                case 6: {
+                    if (tag === 53) {
+                        message.in.push(reader.fixed32());
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(reader.fixed32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 61) {
+                        message.notIn.push(reader.fixed32());
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(reader.fixed32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 69) {
+                        message.example.push(reader.fixed32());
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.fixed32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return Fixed32Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFixed32Rules();
+        message.const = object.const ?? 0;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseFixed64Rules() {
+    return {
+        const: Long.UZERO,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        example: [],
+    };
+}
+export const Fixed64Rules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && !message.const.equals(Long.UZERO)) {
+            writer.uint32(9).fixed64(message.const.toString());
+        }
+        if (message.lt !== undefined) {
+            writer.uint32(17).fixed64(message.lt.toString());
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(25).fixed64(message.lte.toString());
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(33).fixed64(message.gt.toString());
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(41).fixed64(message.gte.toString());
+        }
+        for (const v of message.in) {
+            writer.uint32(49).fixed64(v.toString());
+        }
+        for (const v of message.notIn) {
+            writer.uint32(57).fixed64(v.toString());
+        }
+        for (const v of message.example) {
+            writer.uint32(65).fixed64(v.toString());
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseFixed64Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.const = Long.fromString(reader.fixed64().toString(), true);
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.lt = Long.fromString(reader.fixed64().toString(), true);
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 25) {
+                        break;
+                    }
+                    message.lte = Long.fromString(reader.fixed64().toString(), true);
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 33) {
+                        break;
+                    }
+                    message.gt = Long.fromString(reader.fixed64().toString(), true);
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 41) {
+                        break;
+                    }
+                    message.gte = Long.fromString(reader.fixed64().toString(), true);
+                    continue;
+                }
+                case 6: {
+                    if (tag === 49) {
+                        message.in.push(Long.fromString(reader.fixed64().toString(), true));
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(Long.fromString(reader.fixed64().toString(), true));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 57) {
+                        message.notIn.push(Long.fromString(reader.fixed64().toString(), true));
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(Long.fromString(reader.fixed64().toString(), true));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 65) {
+                        message.example.push(Long.fromString(reader.fixed64().toString(), true));
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(Long.fromString(reader.fixed64().toString(), true));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return Fixed64Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFixed64Rules();
+        message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.UZERO;
+        message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : undefined;
+        message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : undefined;
+        message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : undefined;
+        message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : undefined;
+        message.in = object.in?.map((e) => Long.fromValue(e)) || [];
+        message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
+        message.example = object.example?.map((e) => Long.fromValue(e)) || [];
+        return message;
+    },
+};
+function createBaseSFixed32Rules() {
+    return { const: 0, lt: undefined, lte: undefined, gt: undefined, gte: undefined, in: [], notIn: [], example: [] };
+}
+export const SFixed32Rules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && message.const !== 0) {
+            writer.uint32(13).sfixed32(message.const);
+        }
+        if (message.lt !== undefined) {
+            writer.uint32(21).sfixed32(message.lt);
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(29).sfixed32(message.lte);
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(37).sfixed32(message.gt);
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(45).sfixed32(message.gte);
+        }
+        for (const v of message.in) {
+            writer.uint32(53).sfixed32(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(61).sfixed32(v);
+        }
+        for (const v of message.example) {
+            writer.uint32(69).sfixed32(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSFixed32Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.const = reader.sfixed32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 21) {
+                        break;
+                    }
+                    message.lt = reader.sfixed32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.lte = reader.sfixed32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 37) {
+                        break;
+                    }
+                    message.gt = reader.sfixed32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 45) {
+                        break;
+                    }
+                    message.gte = reader.sfixed32();
+                    continue;
+                }
+                case 6: {
+                    if (tag === 53) {
+                        message.in.push(reader.sfixed32());
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(reader.sfixed32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 61) {
+                        message.notIn.push(reader.sfixed32());
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(reader.sfixed32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 69) {
+                        message.example.push(reader.sfixed32());
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.sfixed32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return SFixed32Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSFixed32Rules();
+        message.const = object.const ?? 0;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseSFixed64Rules() {
+    return {
+        const: Long.ZERO,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        example: [],
+    };
+}
+export const SFixed64Rules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && !message.const.equals(Long.ZERO)) {
+            writer.uint32(9).sfixed64(message.const.toString());
+        }
+        if (message.lt !== undefined) {
+            writer.uint32(17).sfixed64(message.lt.toString());
+        }
+        if (message.lte !== undefined) {
+            writer.uint32(25).sfixed64(message.lte.toString());
+        }
+        if (message.gt !== undefined) {
+            writer.uint32(33).sfixed64(message.gt.toString());
+        }
+        if (message.gte !== undefined) {
+            writer.uint32(41).sfixed64(message.gte.toString());
+        }
+        for (const v of message.in) {
+            writer.uint32(49).sfixed64(v.toString());
+        }
+        for (const v of message.notIn) {
+            writer.uint32(57).sfixed64(v.toString());
+        }
+        for (const v of message.example) {
+            writer.uint32(65).sfixed64(v.toString());
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSFixed64Rules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.const = Long.fromString(reader.sfixed64().toString());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 17) {
+                        break;
+                    }
+                    message.lt = Long.fromString(reader.sfixed64().toString());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 25) {
+                        break;
+                    }
+                    message.lte = Long.fromString(reader.sfixed64().toString());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 33) {
+                        break;
+                    }
+                    message.gt = Long.fromString(reader.sfixed64().toString());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 41) {
+                        break;
+                    }
+                    message.gte = Long.fromString(reader.sfixed64().toString());
+                    continue;
+                }
+                case 6: {
+                    if (tag === 49) {
+                        message.in.push(Long.fromString(reader.sfixed64().toString()));
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(Long.fromString(reader.sfixed64().toString()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 57) {
+                        message.notIn.push(Long.fromString(reader.sfixed64().toString()));
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(Long.fromString(reader.sfixed64().toString()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 8: {
+                    if (tag === 65) {
+                        message.example.push(Long.fromString(reader.sfixed64().toString()));
+                        continue;
+                    }
+                    if (tag === 66) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(Long.fromString(reader.sfixed64().toString()));
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return SFixed64Rules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseSFixed64Rules();
+        message.const = (object.const !== undefined && object.const !== null) ? Long.fromValue(object.const) : Long.ZERO;
+        message.lt = (object.lt !== undefined && object.lt !== null) ? Long.fromValue(object.lt) : undefined;
+        message.lte = (object.lte !== undefined && object.lte !== null) ? Long.fromValue(object.lte) : undefined;
+        message.gt = (object.gt !== undefined && object.gt !== null) ? Long.fromValue(object.gt) : undefined;
+        message.gte = (object.gte !== undefined && object.gte !== null) ? Long.fromValue(object.gte) : undefined;
+        message.in = object.in?.map((e) => Long.fromValue(e)) || [];
+        message.notIn = object.notIn?.map((e) => Long.fromValue(e)) || [];
+        message.example = object.example?.map((e) => Long.fromValue(e)) || [];
+        return message;
+    },
+};
+function createBaseBoolRules() {
+    return { const: false, example: [] };
+}
+export const BoolRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && message.const !== false) {
+            writer.uint32(8).bool(message.const);
+        }
+        for (const v of message.example) {
+            writer.uint32(16).bool(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBoolRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.const = reader.bool();
+                    continue;
+                }
+                case 2: {
+                    if (tag === 16) {
+                        message.example.push(reader.bool());
+                        continue;
+                    }
+                    if (tag === 18) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.bool());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return BoolRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseBoolRules();
+        message.const = object.const ?? false;
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseStringRules() {
+    return {
+        const: "",
+        len: Long.UZERO,
+        minLen: Long.UZERO,
+        maxLen: Long.UZERO,
+        lenBytes: Long.UZERO,
+        minBytes: Long.UZERO,
+        maxBytes: Long.UZERO,
+        pattern: "",
+        prefix: "",
+        suffix: "",
+        contains: "",
+        notContains: "",
+        in: [],
+        notIn: [],
+        email: undefined,
+        hostname: undefined,
+        ip: undefined,
+        ipv4: undefined,
+        ipv6: undefined,
+        uri: undefined,
+        uriRef: undefined,
+        address: undefined,
+        uuid: undefined,
+        tuuid: undefined,
+        ipWithPrefixlen: undefined,
+        ipv4WithPrefixlen: undefined,
+        ipv6WithPrefixlen: undefined,
+        ipPrefix: undefined,
+        ipv4Prefix: undefined,
+        ipv6Prefix: undefined,
+        hostAndPort: undefined,
+        ulid: undefined,
+        wellKnownRegex: undefined,
+        strict: false,
+        example: [],
+    };
+}
+export const StringRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && message.const !== "") {
+            writer.uint32(10).string(message.const);
+        }
+        if (message.len !== undefined && !message.len.equals(Long.UZERO)) {
+            writer.uint32(152).uint64(message.len.toString());
+        }
+        if (message.minLen !== undefined && !message.minLen.equals(Long.UZERO)) {
+            writer.uint32(16).uint64(message.minLen.toString());
+        }
+        if (message.maxLen !== undefined && !message.maxLen.equals(Long.UZERO)) {
+            writer.uint32(24).uint64(message.maxLen.toString());
+        }
+        if (message.lenBytes !== undefined && !message.lenBytes.equals(Long.UZERO)) {
+            writer.uint32(160).uint64(message.lenBytes.toString());
+        }
+        if (message.minBytes !== undefined && !message.minBytes.equals(Long.UZERO)) {
+            writer.uint32(32).uint64(message.minBytes.toString());
+        }
+        if (message.maxBytes !== undefined && !message.maxBytes.equals(Long.UZERO)) {
+            writer.uint32(40).uint64(message.maxBytes.toString());
+        }
+        if (message.pattern !== undefined && message.pattern !== "") {
+            writer.uint32(50).string(message.pattern);
+        }
+        if (message.prefix !== undefined && message.prefix !== "") {
+            writer.uint32(58).string(message.prefix);
+        }
+        if (message.suffix !== undefined && message.suffix !== "") {
+            writer.uint32(66).string(message.suffix);
+        }
+        if (message.contains !== undefined && message.contains !== "") {
+            writer.uint32(74).string(message.contains);
+        }
+        if (message.notContains !== undefined && message.notContains !== "") {
+            writer.uint32(186).string(message.notContains);
+        }
+        for (const v of message.in) {
+            writer.uint32(82).string(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(90).string(v);
+        }
+        if (message.email !== undefined) {
+            writer.uint32(96).bool(message.email);
+        }
+        if (message.hostname !== undefined) {
+            writer.uint32(104).bool(message.hostname);
+        }
+        if (message.ip !== undefined) {
+            writer.uint32(112).bool(message.ip);
+        }
+        if (message.ipv4 !== undefined) {
+            writer.uint32(120).bool(message.ipv4);
+        }
+        if (message.ipv6 !== undefined) {
+            writer.uint32(128).bool(message.ipv6);
+        }
+        if (message.uri !== undefined) {
+            writer.uint32(136).bool(message.uri);
+        }
+        if (message.uriRef !== undefined) {
+            writer.uint32(144).bool(message.uriRef);
+        }
+        if (message.address !== undefined) {
+            writer.uint32(168).bool(message.address);
+        }
+        if (message.uuid !== undefined) {
+            writer.uint32(176).bool(message.uuid);
+        }
+        if (message.tuuid !== undefined) {
+            writer.uint32(264).bool(message.tuuid);
+        }
+        if (message.ipWithPrefixlen !== undefined) {
+            writer.uint32(208).bool(message.ipWithPrefixlen);
+        }
+        if (message.ipv4WithPrefixlen !== undefined) {
+            writer.uint32(216).bool(message.ipv4WithPrefixlen);
+        }
+        if (message.ipv6WithPrefixlen !== undefined) {
+            writer.uint32(224).bool(message.ipv6WithPrefixlen);
+        }
+        if (message.ipPrefix !== undefined) {
+            writer.uint32(232).bool(message.ipPrefix);
+        }
+        if (message.ipv4Prefix !== undefined) {
+            writer.uint32(240).bool(message.ipv4Prefix);
+        }
+        if (message.ipv6Prefix !== undefined) {
+            writer.uint32(248).bool(message.ipv6Prefix);
+        }
+        if (message.hostAndPort !== undefined) {
+            writer.uint32(256).bool(message.hostAndPort);
+        }
+        if (message.ulid !== undefined) {
+            writer.uint32(280).bool(message.ulid);
+        }
+        if (message.wellKnownRegex !== undefined) {
+            writer.uint32(192).int32(message.wellKnownRegex);
+        }
+        if (message.strict !== undefined && message.strict !== false) {
+            writer.uint32(200).bool(message.strict);
+        }
+        for (const v of message.example) {
+            writer.uint32(274).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseStringRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.const = reader.string();
+                    continue;
+                }
+                case 19: {
+                    if (tag !== 152) {
+                        break;
+                    }
+                    message.len = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.minLen = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.maxLen = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 160) {
+                        break;
+                    }
+                    message.lenBytes = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.minBytes = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.maxBytes = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.pattern = reader.string();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.prefix = reader.string();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.suffix = reader.string();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.contains = reader.string();
+                    continue;
+                }
+                case 23: {
+                    if (tag !== 186) {
+                        break;
+                    }
+                    message.notContains = reader.string();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.in.push(reader.string());
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.notIn.push(reader.string());
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.email = reader.bool();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.hostname = reader.bool();
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 112) {
+                        break;
+                    }
+                    message.ip = reader.bool();
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 120) {
+                        break;
+                    }
+                    message.ipv4 = reader.bool();
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 128) {
+                        break;
+                    }
+                    message.ipv6 = reader.bool();
+                    continue;
+                }
+                case 17: {
+                    if (tag !== 136) {
+                        break;
+                    }
+                    message.uri = reader.bool();
+                    continue;
+                }
+                case 18: {
+                    if (tag !== 144) {
+                        break;
+                    }
+                    message.uriRef = reader.bool();
+                    continue;
+                }
+                case 21: {
+                    if (tag !== 168) {
+                        break;
+                    }
+                    message.address = reader.bool();
+                    continue;
+                }
+                case 22: {
+                    if (tag !== 176) {
+                        break;
+                    }
+                    message.uuid = reader.bool();
+                    continue;
+                }
+                case 33: {
+                    if (tag !== 264) {
+                        break;
+                    }
+                    message.tuuid = reader.bool();
+                    continue;
+                }
+                case 26: {
+                    if (tag !== 208) {
+                        break;
+                    }
+                    message.ipWithPrefixlen = reader.bool();
+                    continue;
+                }
+                case 27: {
+                    if (tag !== 216) {
+                        break;
+                    }
+                    message.ipv4WithPrefixlen = reader.bool();
+                    continue;
+                }
+                case 28: {
+                    if (tag !== 224) {
+                        break;
+                    }
+                    message.ipv6WithPrefixlen = reader.bool();
+                    continue;
+                }
+                case 29: {
+                    if (tag !== 232) {
+                        break;
+                    }
+                    message.ipPrefix = reader.bool();
+                    continue;
+                }
+                case 30: {
+                    if (tag !== 240) {
+                        break;
+                    }
+                    message.ipv4Prefix = reader.bool();
+                    continue;
+                }
+                case 31: {
+                    if (tag !== 248) {
+                        break;
+                    }
+                    message.ipv6Prefix = reader.bool();
+                    continue;
+                }
+                case 32: {
+                    if (tag !== 256) {
+                        break;
+                    }
+                    message.hostAndPort = reader.bool();
+                    continue;
+                }
+                case 35: {
+                    if (tag !== 280) {
+                        break;
+                    }
+                    message.ulid = reader.bool();
+                    continue;
+                }
+                case 24: {
+                    if (tag !== 192) {
+                        break;
+                    }
+                    message.wellKnownRegex = reader.int32();
+                    continue;
+                }
+                case 25: {
+                    if (tag !== 200) {
+                        break;
+                    }
+                    message.strict = reader.bool();
+                    continue;
+                }
+                case 34: {
+                    if (tag !== 274) {
+                        break;
+                    }
+                    message.example.push(reader.string());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return StringRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseStringRules();
+        message.const = object.const ?? "";
+        message.len = (object.len !== undefined && object.len !== null) ? Long.fromValue(object.len) : Long.UZERO;
+        message.minLen = (object.minLen !== undefined && object.minLen !== null)
+            ? Long.fromValue(object.minLen)
+            : Long.UZERO;
+        message.maxLen = (object.maxLen !== undefined && object.maxLen !== null)
+            ? Long.fromValue(object.maxLen)
+            : Long.UZERO;
+        message.lenBytes = (object.lenBytes !== undefined && object.lenBytes !== null)
+            ? Long.fromValue(object.lenBytes)
+            : Long.UZERO;
+        message.minBytes = (object.minBytes !== undefined && object.minBytes !== null)
+            ? Long.fromValue(object.minBytes)
+            : Long.UZERO;
+        message.maxBytes = (object.maxBytes !== undefined && object.maxBytes !== null)
+            ? Long.fromValue(object.maxBytes)
+            : Long.UZERO;
+        message.pattern = object.pattern ?? "";
+        message.prefix = object.prefix ?? "";
+        message.suffix = object.suffix ?? "";
+        message.contains = object.contains ?? "";
+        message.notContains = object.notContains ?? "";
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.email = object.email ?? undefined;
+        message.hostname = object.hostname ?? undefined;
+        message.ip = object.ip ?? undefined;
+        message.ipv4 = object.ipv4 ?? undefined;
+        message.ipv6 = object.ipv6 ?? undefined;
+        message.uri = object.uri ?? undefined;
+        message.uriRef = object.uriRef ?? undefined;
+        message.address = object.address ?? undefined;
+        message.uuid = object.uuid ?? undefined;
+        message.tuuid = object.tuuid ?? undefined;
+        message.ipWithPrefixlen = object.ipWithPrefixlen ?? undefined;
+        message.ipv4WithPrefixlen = object.ipv4WithPrefixlen ?? undefined;
+        message.ipv6WithPrefixlen = object.ipv6WithPrefixlen ?? undefined;
+        message.ipPrefix = object.ipPrefix ?? undefined;
+        message.ipv4Prefix = object.ipv4Prefix ?? undefined;
+        message.ipv6Prefix = object.ipv6Prefix ?? undefined;
+        message.hostAndPort = object.hostAndPort ?? undefined;
+        message.ulid = object.ulid ?? undefined;
+        message.wellKnownRegex = object.wellKnownRegex ?? undefined;
+        message.strict = object.strict ?? false;
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseBytesRules() {
+    return {
+        const: new Uint8Array(0),
+        len: Long.UZERO,
+        minLen: Long.UZERO,
+        maxLen: Long.UZERO,
+        pattern: "",
+        prefix: new Uint8Array(0),
+        suffix: new Uint8Array(0),
+        contains: new Uint8Array(0),
+        in: [],
+        notIn: [],
+        ip: undefined,
+        ipv4: undefined,
+        ipv6: undefined,
+        uuid: undefined,
+        example: [],
+    };
+}
+export const BytesRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && message.const.length !== 0) {
+            writer.uint32(10).bytes(message.const);
+        }
+        if (message.len !== undefined && !message.len.equals(Long.UZERO)) {
+            writer.uint32(104).uint64(message.len.toString());
+        }
+        if (message.minLen !== undefined && !message.minLen.equals(Long.UZERO)) {
+            writer.uint32(16).uint64(message.minLen.toString());
+        }
+        if (message.maxLen !== undefined && !message.maxLen.equals(Long.UZERO)) {
+            writer.uint32(24).uint64(message.maxLen.toString());
+        }
+        if (message.pattern !== undefined && message.pattern !== "") {
+            writer.uint32(34).string(message.pattern);
+        }
+        if (message.prefix !== undefined && message.prefix.length !== 0) {
+            writer.uint32(42).bytes(message.prefix);
+        }
+        if (message.suffix !== undefined && message.suffix.length !== 0) {
+            writer.uint32(50).bytes(message.suffix);
+        }
+        if (message.contains !== undefined && message.contains.length !== 0) {
+            writer.uint32(58).bytes(message.contains);
+        }
+        for (const v of message.in) {
+            writer.uint32(66).bytes(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(74).bytes(v);
+        }
+        if (message.ip !== undefined) {
+            writer.uint32(80).bool(message.ip);
+        }
+        if (message.ipv4 !== undefined) {
+            writer.uint32(88).bool(message.ipv4);
+        }
+        if (message.ipv6 !== undefined) {
+            writer.uint32(96).bool(message.ipv6);
+        }
+        if (message.uuid !== undefined) {
+            writer.uint32(120).bool(message.uuid);
+        }
+        for (const v of message.example) {
+            writer.uint32(114).bytes(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBytesRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.const = reader.bytes();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.len = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.minLen = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.maxLen = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.pattern = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.prefix = reader.bytes();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.suffix = reader.bytes();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.contains = reader.bytes();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.in.push(reader.bytes());
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.notIn.push(reader.bytes());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.ip = reader.bool();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.ipv4 = reader.bool();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 96) {
+                        break;
+                    }
+                    message.ipv6 = reader.bool();
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 120) {
+                        break;
+                    }
+                    message.uuid = reader.bool();
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 114) {
+                        break;
+                    }
+                    message.example.push(reader.bytes());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return BytesRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseBytesRules();
+        message.const = object.const ?? new Uint8Array(0);
+        message.len = (object.len !== undefined && object.len !== null) ? Long.fromValue(object.len) : Long.UZERO;
+        message.minLen = (object.minLen !== undefined && object.minLen !== null)
+            ? Long.fromValue(object.minLen)
+            : Long.UZERO;
+        message.maxLen = (object.maxLen !== undefined && object.maxLen !== null)
+            ? Long.fromValue(object.maxLen)
+            : Long.UZERO;
+        message.pattern = object.pattern ?? "";
+        message.prefix = object.prefix ?? new Uint8Array(0);
+        message.suffix = object.suffix ?? new Uint8Array(0);
+        message.contains = object.contains ?? new Uint8Array(0);
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.ip = object.ip ?? undefined;
+        message.ipv4 = object.ipv4 ?? undefined;
+        message.ipv6 = object.ipv6 ?? undefined;
+        message.uuid = object.uuid ?? undefined;
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseEnumRules() {
+    return { const: 0, definedOnly: false, in: [], notIn: [], example: [] };
+}
+export const EnumRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined && message.const !== 0) {
+            writer.uint32(8).int32(message.const);
+        }
+        if (message.definedOnly !== undefined && message.definedOnly !== false) {
+            writer.uint32(16).bool(message.definedOnly);
+        }
+        for (const v of message.in) {
+            writer.uint32(24).int32(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(32).int32(v);
+        }
+        for (const v of message.example) {
+            writer.uint32(40).int32(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEnumRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.const = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.definedOnly = reader.bool();
+                    continue;
+                }
+                case 3: {
+                    if (tag === 24) {
+                        message.in.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 26) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.in.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 4: {
+                    if (tag === 32) {
+                        message.notIn.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 34) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.notIn.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 5: {
+                    if (tag === 40) {
+                        message.example.push(reader.int32());
+                        continue;
+                    }
+                    if (tag === 42) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.example.push(reader.int32());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return EnumRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEnumRules();
+        message.const = object.const ?? 0;
+        message.definedOnly = object.definedOnly ?? false;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseRepeatedRules() {
+    return { minItems: Long.UZERO, maxItems: Long.UZERO, unique: false, items: undefined };
+}
+export const RepeatedRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.minItems !== undefined && !message.minItems.equals(Long.UZERO)) {
+            writer.uint32(8).uint64(message.minItems.toString());
+        }
+        if (message.maxItems !== undefined && !message.maxItems.equals(Long.UZERO)) {
+            writer.uint32(16).uint64(message.maxItems.toString());
+        }
+        if (message.unique !== undefined && message.unique !== false) {
+            writer.uint32(24).bool(message.unique);
+        }
+        if (message.items !== undefined) {
+            FieldRules.encode(message.items, writer.uint32(34).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRepeatedRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.minItems = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.maxItems = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.unique = reader.bool();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.items = FieldRules.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return RepeatedRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRepeatedRules();
+        message.minItems = (object.minItems !== undefined && object.minItems !== null)
+            ? Long.fromValue(object.minItems)
+            : Long.UZERO;
+        message.maxItems = (object.maxItems !== undefined && object.maxItems !== null)
+            ? Long.fromValue(object.maxItems)
+            : Long.UZERO;
+        message.unique = object.unique ?? false;
+        message.items = (object.items !== undefined && object.items !== null)
+            ? FieldRules.fromPartial(object.items)
+            : undefined;
+        return message;
+    },
+};
+function createBaseMapRules() {
+    return { minPairs: Long.UZERO, maxPairs: Long.UZERO, keys: undefined, values: undefined };
+}
+export const MapRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.minPairs !== undefined && !message.minPairs.equals(Long.UZERO)) {
+            writer.uint32(8).uint64(message.minPairs.toString());
+        }
+        if (message.maxPairs !== undefined && !message.maxPairs.equals(Long.UZERO)) {
+            writer.uint32(16).uint64(message.maxPairs.toString());
+        }
+        if (message.keys !== undefined) {
+            FieldRules.encode(message.keys, writer.uint32(34).fork()).join();
+        }
+        if (message.values !== undefined) {
+            FieldRules.encode(message.values, writer.uint32(42).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 = createBaseMapRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.minPairs = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.maxPairs = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.keys = FieldRules.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.values = FieldRules.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return MapRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseMapRules();
+        message.minPairs = (object.minPairs !== undefined && object.minPairs !== null)
+            ? Long.fromValue(object.minPairs)
+            : Long.UZERO;
+        message.maxPairs = (object.maxPairs !== undefined && object.maxPairs !== null)
+            ? Long.fromValue(object.maxPairs)
+            : Long.UZERO;
+        message.keys = (object.keys !== undefined && object.keys !== null)
+            ? FieldRules.fromPartial(object.keys)
+            : undefined;
+        message.values = (object.values !== undefined && object.values !== null)
+            ? FieldRules.fromPartial(object.values)
+            : undefined;
+        return message;
+    },
+};
+function createBaseAnyRules() {
+    return { in: [], notIn: [] };
+}
+export const AnyRules = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.in) {
+            writer.uint32(18).string(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(26).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAnyRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.in.push(reader.string());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.notIn.push(reader.string());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return AnyRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAnyRules();
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseDurationRules() {
+    return {
+        const: undefined,
+        lt: undefined,
+        lte: undefined,
+        gt: undefined,
+        gte: undefined,
+        in: [],
+        notIn: [],
+        example: [],
+    };
+}
+export const DurationRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined) {
+            Duration.encode(message.const, writer.uint32(18).fork()).join();
+        }
+        if (message.lt !== undefined) {
+            Duration.encode(message.lt, writer.uint32(26).fork()).join();
+        }
+        if (message.lte !== undefined) {
+            Duration.encode(message.lte, writer.uint32(34).fork()).join();
+        }
+        if (message.gt !== undefined) {
+            Duration.encode(message.gt, writer.uint32(42).fork()).join();
+        }
+        if (message.gte !== undefined) {
+            Duration.encode(message.gte, writer.uint32(50).fork()).join();
+        }
+        for (const v of message.in) {
+            Duration.encode(v, writer.uint32(58).fork()).join();
+        }
+        for (const v of message.notIn) {
+            Duration.encode(v, writer.uint32(66).fork()).join();
+        }
+        for (const v of message.example) {
+            Duration.encode(v, writer.uint32(74).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseDurationRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.const = Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.lt = Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.lte = Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.gt = Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.gte = Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.in.push(Duration.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.notIn.push(Duration.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.example.push(Duration.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return DurationRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseDurationRules();
+        message.const = (object.const !== undefined && object.const !== null)
+            ? Duration.fromPartial(object.const)
+            : undefined;
+        message.lt = (object.lt !== undefined && object.lt !== null) ? Duration.fromPartial(object.lt) : undefined;
+        message.lte = (object.lte !== undefined && object.lte !== null) ? Duration.fromPartial(object.lte) : undefined;
+        message.gt = (object.gt !== undefined && object.gt !== null) ? Duration.fromPartial(object.gt) : undefined;
+        message.gte = (object.gte !== undefined && object.gte !== null) ? Duration.fromPartial(object.gte) : undefined;
+        message.in = object.in?.map((e) => Duration.fromPartial(e)) || [];
+        message.notIn = object.notIn?.map((e) => Duration.fromPartial(e)) || [];
+        message.example = object.example?.map((e) => Duration.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseFieldMaskRules() {
+    return { const: undefined, in: [], notIn: [], example: [] };
+}
+export const FieldMaskRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined) {
+            FieldMask.encode(FieldMask.wrap(message.const), writer.uint32(10).fork()).join();
+        }
+        for (const v of message.in) {
+            writer.uint32(18).string(v);
+        }
+        for (const v of message.notIn) {
+            writer.uint32(26).string(v);
+        }
+        for (const v of message.example) {
+            FieldMask.encode(FieldMask.wrap(v), writer.uint32(34).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 = createBaseFieldMaskRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.const = FieldMask.unwrap(FieldMask.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.in.push(reader.string());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.notIn.push(reader.string());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.example.push(FieldMask.unwrap(FieldMask.decode(reader, reader.uint32())));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return FieldMaskRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFieldMaskRules();
+        message.const = object.const ?? undefined;
+        message.in = object.in?.map((e) => e) || [];
+        message.notIn = object.notIn?.map((e) => e) || [];
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseTimestampRules() {
+    return {
+        const: undefined,
+        lt: undefined,
+        lte: undefined,
+        ltNow: undefined,
+        gt: undefined,
+        gte: undefined,
+        gtNow: undefined,
+        within: undefined,
+        example: [],
+    };
+}
+export const TimestampRules = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.const !== undefined) {
+            Timestamp.encode(toTimestamp(message.const), writer.uint32(18).fork()).join();
+        }
+        if (message.lt !== undefined) {
+            Timestamp.encode(toTimestamp(message.lt), writer.uint32(26).fork()).join();
+        }
+        if (message.lte !== undefined) {
+            Timestamp.encode(toTimestamp(message.lte), writer.uint32(34).fork()).join();
+        }
+        if (message.ltNow !== undefined) {
+            writer.uint32(56).bool(message.ltNow);
+        }
+        if (message.gt !== undefined) {
+            Timestamp.encode(toTimestamp(message.gt), writer.uint32(42).fork()).join();
+        }
+        if (message.gte !== undefined) {
+            Timestamp.encode(toTimestamp(message.gte), writer.uint32(50).fork()).join();
+        }
+        if (message.gtNow !== undefined) {
+            writer.uint32(64).bool(message.gtNow);
+        }
+        if (message.within !== undefined) {
+            Duration.encode(message.within, writer.uint32(74).fork()).join();
+        }
+        for (const v of message.example) {
+            Timestamp.encode(toTimestamp(v), writer.uint32(82).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTimestampRules();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.const = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.lt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.lte = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.ltNow = reader.bool();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.gt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.gte = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.gtNow = reader.bool();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.within = Duration.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.example.push(fromTimestamp(Timestamp.decode(reader, reader.uint32())));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return TimestampRules.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTimestampRules();
+        message.const = object.const ?? undefined;
+        message.lt = object.lt ?? undefined;
+        message.lte = object.lte ?? undefined;
+        message.ltNow = object.ltNow ?? undefined;
+        message.gt = object.gt ?? undefined;
+        message.gte = object.gte ?? undefined;
+        message.gtNow = object.gtNow ?? undefined;
+        message.within = (object.within !== undefined && object.within !== null)
+            ? Duration.fromPartial(object.within)
+            : undefined;
+        message.example = object.example?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseViolations() {
+    return { violations: [] };
+}
+export const Violations = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.violations) {
+            Violation.encode(v, writer.uint32(10).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 = createBaseViolations();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.violations.push(Violation.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return Violations.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseViolations();
+        message.violations = object.violations?.map((e) => Violation.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseViolation() {
+    return { field: undefined, rule: undefined, ruleId: "", message: "", forKey: false };
+}
+export const Violation = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.field !== undefined) {
+            FieldPath.encode(message.field, writer.uint32(42).fork()).join();
+        }
+        if (message.rule !== undefined) {
+            FieldPath.encode(message.rule, writer.uint32(50).fork()).join();
+        }
+        if (message.ruleId !== undefined && message.ruleId !== "") {
+            writer.uint32(18).string(message.ruleId);
+        }
+        if (message.message !== undefined && message.message !== "") {
+            writer.uint32(26).string(message.message);
+        }
+        if (message.forKey !== undefined && message.forKey !== false) {
+            writer.uint32(32).bool(message.forKey);
+        }
+        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 = createBaseViolation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.field = FieldPath.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.rule = FieldPath.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ruleId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.message = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.forKey = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return Violation.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseViolation();
+        message.field = (object.field !== undefined && object.field !== null)
+            ? FieldPath.fromPartial(object.field)
+            : undefined;
+        message.rule = (object.rule !== undefined && object.rule !== null) ? FieldPath.fromPartial(object.rule) : undefined;
+        message.ruleId = object.ruleId ?? "";
+        message.message = object.message ?? "";
+        message.forKey = object.forKey ?? false;
+        return message;
+    },
+};
+function createBaseFieldPath() {
+    return { elements: [] };
+}
+export const FieldPath = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.elements) {
+            FieldPathElement.encode(v, writer.uint32(10).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 = createBaseFieldPath();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.elements.push(FieldPathElement.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return FieldPath.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFieldPath();
+        message.elements = object.elements?.map((e) => FieldPathElement.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseFieldPathElement() {
+    return {
+        fieldNumber: 0,
+        fieldName: "",
+        fieldType: 1,
+        keyType: 1,
+        valueType: 1,
+        index: undefined,
+        boolKey: undefined,
+        intKey: undefined,
+        uintKey: undefined,
+        stringKey: undefined,
+    };
+}
+export const FieldPathElement = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.fieldNumber !== undefined && message.fieldNumber !== 0) {
+            writer.uint32(8).int32(message.fieldNumber);
+        }
+        if (message.fieldName !== undefined && message.fieldName !== "") {
+            writer.uint32(18).string(message.fieldName);
+        }
+        if (message.fieldType !== undefined && message.fieldType !== 1) {
+            writer.uint32(24).int32(message.fieldType);
+        }
+        if (message.keyType !== undefined && message.keyType !== 1) {
+            writer.uint32(32).int32(message.keyType);
+        }
+        if (message.valueType !== undefined && message.valueType !== 1) {
+            writer.uint32(40).int32(message.valueType);
+        }
+        if (message.index !== undefined) {
+            writer.uint32(48).uint64(message.index.toString());
+        }
+        if (message.boolKey !== undefined) {
+            writer.uint32(56).bool(message.boolKey);
+        }
+        if (message.intKey !== undefined) {
+            writer.uint32(64).int64(message.intKey.toString());
+        }
+        if (message.uintKey !== undefined) {
+            writer.uint32(72).uint64(message.uintKey.toString());
+        }
+        if (message.stringKey !== undefined) {
+            writer.uint32(82).string(message.stringKey);
+        }
+        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 = createBaseFieldPathElement();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.fieldNumber = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.fieldName = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.fieldType = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.keyType = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.valueType = reader.int32();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.index = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.boolKey = reader.bool();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.intKey = Long.fromString(reader.int64().toString());
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 72) {
+                        break;
+                    }
+                    message.uintKey = Long.fromString(reader.uint64().toString(), true);
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.stringKey = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    create(base) {
+        return FieldPathElement.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseFieldPathElement();
+        message.fieldNumber = object.fieldNumber ?? 0;
+        message.fieldName = object.fieldName ?? "";
+        message.fieldType = object.fieldType ?? 1;
+        message.keyType = object.keyType ?? 1;
+        message.valueType = object.valueType ?? 1;
+        message.index = (object.index !== undefined && object.index !== null) ? Long.fromValue(object.index) : undefined;
+        message.boolKey = object.boolKey ?? undefined;
+        message.intKey = (object.intKey !== undefined && object.intKey !== null)
+            ? Long.fromValue(object.intKey)
+            : undefined;
+        message.uintKey = (object.uintKey !== undefined && object.uintKey !== null)
+            ? Long.fromValue(object.uintKey)
+            : undefined;
+        message.stringKey = object.stringKey ?? undefined;
+        return message;
+    },
+};
+function toTimestamp(date) {
+    const seconds = numberToLong(Math.trunc(date.getTime() / 1_000));
+    const nanos = (date.getTime() % 1_000) * 1_000_000;
+    return { seconds, nanos };
+}
+function fromTimestamp(t) {
+    let millis = (t.seconds.toNumber() || 0) * 1_000;
+    millis += (t.nanos || 0) / 1_000_000;
+    return new globalThis.Date(millis);
+}
+function numberToLong(number) {
+    return Long.fromNumber(number);
+}