@cerbos/grpc/src/protobuf/buf/validate/validate.ts

Client library for interacting with the Cerbos policy decision point service over gRPC from server-side Node.js applications

// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
// source: buf/validate/validate.proto

/* eslint-disable */
import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
import { Duration } from "../../google/protobuf/duration";
import { Timestamp } from "../../google/protobuf/timestamp";

export const protobufPackage = "buf.validate";

export enum Ignore {
  IGNORE_UNSPECIFIED = 0,
  IGNORE_IF_UNPOPULATED = 1,
  IGNORE_IF_DEFAULT_VALUE = 2,
  IGNORE_ALWAYS = 3,
}

export enum KnownRegex {
  KNOWN_REGEX_UNSPECIFIED = 0,
  KNOWN_REGEX_HTTP_HEADER_NAME = 1,
  KNOWN_REGEX_HTTP_HEADER_VALUE = 2,
}

export interface Rule {
  id?: string | undefined;
  message?: string | undefined;
  expression?: string | undefined;
}

export interface MessageRules {
  disabled?: boolean | undefined;
  cel: Rule[];
}

export interface OneofRules {
  required?: boolean | undefined;
}

export interface FieldRules {
  cel: Rule[];
  required?: boolean | undefined;
  ignore?: Ignore | undefined;
  type?:
    | { $case: "float"; float: FloatRules }
    | { $case: "double"; double: DoubleRules }
    | { $case: "int32"; int32: Int32Rules }
    | { $case: "int64"; int64: Int64Rules }
    | { $case: "uint32"; uint32: UInt32Rules }
    | { $case: "uint64"; uint64: UInt64Rules }
    | { $case: "sint32"; sint32: SInt32Rules }
    | { $case: "sint64"; sint64: SInt64Rules }
    | { $case: "fixed32"; fixed32: Fixed32Rules }
    | { $case: "fixed64"; fixed64: Fixed64Rules }
    | { $case: "sfixed32"; sfixed32: SFixed32Rules }
    | { $case: "sfixed64"; sfixed64: SFixed64Rules }
    | { $case: "bool"; bool: BoolRules }
    | { $case: "string"; string: StringRules }
    | { $case: "bytes"; bytes: BytesRules }
    | { $case: "enum"; enum: EnumRules }
    | { $case: "repeated"; repeated: RepeatedRules }
    | { $case: "map"; map: MapRules }
    | { $case: "any"; any: AnyRules }
    | { $case: "duration"; duration: DurationRules }
    | { $case: "timestamp"; timestamp: TimestampRules }
    | undefined;
}

export interface PredefinedRules {
  cel: Rule[];
}

export interface FloatRules {
  const?: number | undefined;
  lessThan?:
    | { $case: "lt"; lt: number }
    | { $case: "lte"; lte: number }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: number }
    | { $case: "gte"; gte: number }
    | undefined;
  in: number[];
  notIn: number[];
  finite?: boolean | undefined;
  example: number[];
}

export interface DoubleRules {
  const?: number | undefined;
  lessThan?:
    | { $case: "lt"; lt: number }
    | { $case: "lte"; lte: number }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: number }
    | { $case: "gte"; gte: number }
    | undefined;
  in: number[];
  notIn: number[];
  finite?: boolean | undefined;
  example: number[];
}

export interface Int32Rules {
  const?: number | undefined;
  lessThan?:
    | { $case: "lt"; lt: number }
    | { $case: "lte"; lte: number }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: number }
    | { $case: "gte"; gte: number }
    | undefined;
  in: number[];
  notIn: number[];
  example: number[];
}

export interface Int64Rules {
  const?: string | undefined;
  lessThan?:
    | { $case: "lt"; lt: string }
    | { $case: "lte"; lte: string }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: string }
    | { $case: "gte"; gte: string }
    | undefined;
  in: string[];
  notIn: string[];
  example: string[];
}

export interface UInt32Rules {
  const?: number | undefined;
  lessThan?:
    | { $case: "lt"; lt: number }
    | { $case: "lte"; lte: number }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: number }
    | { $case: "gte"; gte: number }
    | undefined;
  in: number[];
  notIn: number[];
  example: number[];
}

export interface UInt64Rules {
  const?: string | undefined;
  lessThan?:
    | { $case: "lt"; lt: string }
    | { $case: "lte"; lte: string }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: string }
    | { $case: "gte"; gte: string }
    | undefined;
  in: string[];
  notIn: string[];
  example: string[];
}

export interface SInt32Rules {
  const?: number | undefined;
  lessThan?:
    | { $case: "lt"; lt: number }
    | { $case: "lte"; lte: number }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: number }
    | { $case: "gte"; gte: number }
    | undefined;
  in: number[];
  notIn: number[];
  example: number[];
}

export interface SInt64Rules {
  const?: string | undefined;
  lessThan?:
    | { $case: "lt"; lt: string }
    | { $case: "lte"; lte: string }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: string }
    | { $case: "gte"; gte: string }
    | undefined;
  in: string[];
  notIn: string[];
  example: string[];
}

export interface Fixed32Rules {
  const?: number | undefined;
  lessThan?:
    | { $case: "lt"; lt: number }
    | { $case: "lte"; lte: number }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: number }
    | { $case: "gte"; gte: number }
    | undefined;
  in: number[];
  notIn: number[];
  example: number[];
}

export interface Fixed64Rules {
  const?: string | undefined;
  lessThan?:
    | { $case: "lt"; lt: string }
    | { $case: "lte"; lte: string }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: string }
    | { $case: "gte"; gte: string }
    | undefined;
  in: string[];
  notIn: string[];
  example: string[];
}

export interface SFixed32Rules {
  const?: number | undefined;
  lessThan?:
    | { $case: "lt"; lt: number }
    | { $case: "lte"; lte: number }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: number }
    | { $case: "gte"; gte: number }
    | undefined;
  in: number[];
  notIn: number[];
  example: number[];
}

export interface SFixed64Rules {
  const?: string | undefined;
  lessThan?:
    | { $case: "lt"; lt: string }
    | { $case: "lte"; lte: string }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: string }
    | { $case: "gte"; gte: string }
    | undefined;
  in: string[];
  notIn: string[];
  example: string[];
}

export interface BoolRules {
  const?: boolean | undefined;
  example: boolean[];
}

export interface StringRules {
  const?: string | undefined;
  len?: string | undefined;
  minLen?: string | undefined;
  maxLen?: string | undefined;
  lenBytes?: string | undefined;
  minBytes?: string | undefined;
  maxBytes?: string | undefined;
  pattern?: string | undefined;
  prefix?: string | undefined;
  suffix?: string | undefined;
  contains?: string | undefined;
  notContains?: string | undefined;
  in: string[];
  notIn: string[];
  wellKnown?:
    | { $case: "email"; email: boolean }
    | { $case: "hostname"; hostname: boolean }
    | { $case: "ip"; ip: boolean }
    | { $case: "ipv4"; ipv4: boolean }
    | { $case: "ipv6"; ipv6: boolean }
    | { $case: "uri"; uri: boolean }
    | { $case: "uriRef"; uriRef: boolean }
    | { $case: "address"; address: boolean }
    | { $case: "uuid"; uuid: boolean }
    | { $case: "tuuid"; tuuid: boolean }
    | { $case: "ipWithPrefixlen"; ipWithPrefixlen: boolean }
    | { $case: "ipv4WithPrefixlen"; ipv4WithPrefixlen: boolean }
    | { $case: "ipv6WithPrefixlen"; ipv6WithPrefixlen: boolean }
    | { $case: "ipPrefix"; ipPrefix: boolean }
    | { $case: "ipv4Prefix"; ipv4Prefix: boolean }
    | { $case: "ipv6Prefix"; ipv6Prefix: boolean }
    | { $case: "hostAndPort"; hostAndPort: boolean }
    | { $case: "wellKnownRegex"; wellKnownRegex: KnownRegex }
    | undefined;
  strict?: boolean | undefined;
  example: string[];
}

export interface BytesRules {
  const?: Uint8Array | undefined;
  len?: string | undefined;
  minLen?: string | undefined;
  maxLen?: string | undefined;
  pattern?: string | undefined;
  prefix?: Uint8Array | undefined;
  suffix?: Uint8Array | undefined;
  contains?: Uint8Array | undefined;
  in: Uint8Array[];
  notIn: Uint8Array[];
  wellKnown?:
    | { $case: "ip"; ip: boolean }
    | { $case: "ipv4"; ipv4: boolean }
    | { $case: "ipv6"; ipv6: boolean }
    | undefined;
  example: Uint8Array[];
}

export interface EnumRules {
  const?: number | undefined;
  definedOnly?: boolean | undefined;
  in: number[];
  notIn: number[];
  example: number[];
}

export interface RepeatedRules {
  minItems?: string | undefined;
  maxItems?: string | undefined;
  unique?: boolean | undefined;
  items?: FieldRules | undefined;
}

export interface MapRules {
  minPairs?: string | undefined;
  maxPairs?: string | undefined;
  keys?: FieldRules | undefined;
  values?: FieldRules | undefined;
}

export interface AnyRules {
  in: string[];
  notIn: string[];
}

export interface DurationRules {
  const?: Duration | undefined;
  lessThan?:
    | { $case: "lt"; lt: Duration }
    | { $case: "lte"; lte: Duration }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: Duration }
    | { $case: "gte"; gte: Duration }
    | undefined;
  in: Duration[];
  notIn: Duration[];
  example: Duration[];
}

export interface TimestampRules {
  const?: Date | undefined;
  lessThan?:
    | { $case: "lt"; lt: Date }
    | { $case: "lte"; lte: Date }
    | { $case: "ltNow"; ltNow: boolean }
    | undefined;
  greaterThan?:
    | { $case: "gt"; gt: Date }
    | { $case: "gte"; gte: Date }
    | { $case: "gtNow"; gtNow: boolean }
    | undefined;
  within?: Duration | undefined;
  example: Date[];
}

function createBaseRule(): Rule {
  return { id: "", message: "", expression: "" };
}

export const Rule: MessageFns<Rule> = {
  encode(
    message: Rule,
    writer: BinaryWriter = new BinaryWriter(),
  ): 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: BinaryReader | Uint8Array, length?: number): Rule {
    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;
  },
};

function createBaseMessageRules(): MessageRules {
  return { disabled: false, cel: [] };
}

export const MessageRules: MessageFns<MessageRules> = {
  encode(
    message: MessageRules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.disabled !== undefined && message.disabled !== false) {
      writer.uint32(8).bool(message.disabled);
    }
    for (const v of message.cel) {
      Rule.encode(v!, writer.uint32(26).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): MessageRules {
    const reader =
      input instanceof BinaryReader ? input : new BinaryReader(input);
    const end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseMessageRules();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }

          message.disabled = reader.bool();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.cel.push(Rule.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseOneofRules(): OneofRules {
  return { required: false };
}

export const OneofRules: MessageFns<OneofRules> = {
  encode(
    message: OneofRules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.required !== undefined && message.required !== false) {
      writer.uint32(8).bool(message.required);
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): OneofRules {
    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;
  },
};

function createBaseFieldRules(): FieldRules {
  return { cel: [], required: false, ignore: 0, type: undefined };
}

export const FieldRules: MessageFns<FieldRules> = {
  encode(
    message: FieldRules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    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);
    }
    switch (message.type?.$case) {
      case "float":
        FloatRules.encode(message.type.float, writer.uint32(10).fork()).join();
        break;
      case "double":
        DoubleRules.encode(
          message.type.double,
          writer.uint32(18).fork(),
        ).join();
        break;
      case "int32":
        Int32Rules.encode(message.type.int32, writer.uint32(26).fork()).join();
        break;
      case "int64":
        Int64Rules.encode(message.type.int64, writer.uint32(34).fork()).join();
        break;
      case "uint32":
        UInt32Rules.encode(
          message.type.uint32,
          writer.uint32(42).fork(),
        ).join();
        break;
      case "uint64":
        UInt64Rules.encode(
          message.type.uint64,
          writer.uint32(50).fork(),
        ).join();
        break;
      case "sint32":
        SInt32Rules.encode(
          message.type.sint32,
          writer.uint32(58).fork(),
        ).join();
        break;
      case "sint64":
        SInt64Rules.encode(
          message.type.sint64,
          writer.uint32(66).fork(),
        ).join();
        break;
      case "fixed32":
        Fixed32Rules.encode(
          message.type.fixed32,
          writer.uint32(74).fork(),
        ).join();
        break;
      case "fixed64":
        Fixed64Rules.encode(
          message.type.fixed64,
          writer.uint32(82).fork(),
        ).join();
        break;
      case "sfixed32":
        SFixed32Rules.encode(
          message.type.sfixed32,
          writer.uint32(90).fork(),
        ).join();
        break;
      case "sfixed64":
        SFixed64Rules.encode(
          message.type.sfixed64,
          writer.uint32(98).fork(),
        ).join();
        break;
      case "bool":
        BoolRules.encode(message.type.bool, writer.uint32(106).fork()).join();
        break;
      case "string":
        StringRules.encode(
          message.type.string,
          writer.uint32(114).fork(),
        ).join();
        break;
      case "bytes":
        BytesRules.encode(message.type.bytes, writer.uint32(122).fork()).join();
        break;
      case "enum":
        EnumRules.encode(message.type.enum, writer.uint32(130).fork()).join();
        break;
      case "repeated":
        RepeatedRules.encode(
          message.type.repeated,
          writer.uint32(146).fork(),
        ).join();
        break;
      case "map":
        MapRules.encode(message.type.map, writer.uint32(154).fork()).join();
        break;
      case "any":
        AnyRules.encode(message.type.any, writer.uint32(162).fork()).join();
        break;
      case "duration":
        DurationRules.encode(
          message.type.duration,
          writer.uint32(170).fork(),
        ).join();
        break;
      case "timestamp":
        TimestampRules.encode(
          message.type.timestamp,
          writer.uint32(178).fork(),
        ).join();
        break;
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): FieldRules {
    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 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() as any;
          continue;
        }
        case 1: {
          if (tag !== 10) {
            break;
          }

          message.type = {
            $case: "float",
            float: FloatRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }

          message.type = {
            $case: "double",
            double: DoubleRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }

          message.type = {
            $case: "int32",
            int32: Int32Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }

          message.type = {
            $case: "int64",
            int64: Int64Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }

          message.type = {
            $case: "uint32",
            uint32: UInt32Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 6: {
          if (tag !== 50) {
            break;
          }

          message.type = {
            $case: "uint64",
            uint64: UInt64Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 7: {
          if (tag !== 58) {
            break;
          }

          message.type = {
            $case: "sint32",
            sint32: SInt32Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 8: {
          if (tag !== 66) {
            break;
          }

          message.type = {
            $case: "sint64",
            sint64: SInt64Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 9: {
          if (tag !== 74) {
            break;
          }

          message.type = {
            $case: "fixed32",
            fixed32: Fixed32Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 10: {
          if (tag !== 82) {
            break;
          }

          message.type = {
            $case: "fixed64",
            fixed64: Fixed64Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 11: {
          if (tag !== 90) {
            break;
          }

          message.type = {
            $case: "sfixed32",
            sfixed32: SFixed32Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 12: {
          if (tag !== 98) {
            break;
          }

          message.type = {
            $case: "sfixed64",
            sfixed64: SFixed64Rules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 13: {
          if (tag !== 106) {
            break;
          }

          message.type = {
            $case: "bool",
            bool: BoolRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 14: {
          if (tag !== 114) {
            break;
          }

          message.type = {
            $case: "string",
            string: StringRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 15: {
          if (tag !== 122) {
            break;
          }

          message.type = {
            $case: "bytes",
            bytes: BytesRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 16: {
          if (tag !== 130) {
            break;
          }

          message.type = {
            $case: "enum",
            enum: EnumRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 18: {
          if (tag !== 146) {
            break;
          }

          message.type = {
            $case: "repeated",
            repeated: RepeatedRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 19: {
          if (tag !== 154) {
            break;
          }

          message.type = {
            $case: "map",
            map: MapRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 20: {
          if (tag !== 162) {
            break;
          }

          message.type = {
            $case: "any",
            any: AnyRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 21: {
          if (tag !== 170) {
            break;
          }

          message.type = {
            $case: "duration",
            duration: DurationRules.decode(reader, reader.uint32()),
          };
          continue;
        }
        case 22: {
          if (tag !== 178) {
            break;
          }

          message.type = {
            $case: "timestamp",
            timestamp: TimestampRules.decode(reader, reader.uint32()),
          };
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBasePredefinedRules(): PredefinedRules {
  return { cel: [] };
}

export const PredefinedRules: MessageFns<PredefinedRules> = {
  encode(
    message: PredefinedRules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    for (const v of message.cel) {
      Rule.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): PredefinedRules {
    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;
  },
};

function createBaseFloatRules(): FloatRules {
  return {
    const: 0,
    lessThan: undefined,
    greaterThan: undefined,
    in: [],
    notIn: [],
    finite: false,
    example: [],
  };
}

export const FloatRules: MessageFns<FloatRules> = {
  encode(
    message: FloatRules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.const !== undefined && message.const !== 0) {
      writer.uint32(13).float(message.const);
    }
    switch (message.lessThan?.$case) {
      case "lt":
        writer.uint32(21).float(message.lessThan.lt);
        break;
      case "lte":
        writer.uint32(29).float(message.lessThan.lte);
        break;
    }
    switch (message.greaterThan?.$case) {
      case "gt":
        writer.uint32(37).float(message.greaterThan.gt);
        break;
      case "gte":
        writer.uint32(45).float(message.greaterThan.gte);
        break;
    }
    writer.uint32(50).fork();
    for (const v of message.in) {
      writer.float(v);
    }
    writer.join();
    writer.uint32(58).fork();
    for (const v of message.notIn) {
      writer.float(v);
    }
    writer.join();
    if (message.finite !== undefined && message.finite !== false) {
      writer.uint32(64).bool(message.finite);
    }
    writer.uint32(74).fork();
    for (const v of message.example) {
      writer.float(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): FloatRules {
    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.lessThan = { $case: "lt", lt: reader.float() };
          continue;
        }
        case 3: {
          if (tag !== 29) {
            break;
          }

          message.lessThan = { $case: "lte", lte: reader.float() };
          continue;
        }
        case 4: {
          if (tag !== 37) {
            break;
          }

          message.greaterThan = { $case: "gt", gt: reader.float() };
          continue;
        }
        case 5: {
          if (tag !== 45) {
            break;
          }

          message.greaterThan = { $case: "gte", 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;
  },
};

function createBaseDoubleRules(): DoubleRules {
  return {
    const: 0,
    lessThan: undefined,
    greaterThan: undefined,
    in: [],
    notIn: [],
    finite: false,
    example: [],
  };
}

export const DoubleRules: MessageFns<DoubleRules> = {
  encode(
    message: DoubleRules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.const !== undefined && message.const !== 0) {
      writer.uint32(9).double(message.const);
    }
    switch (message.lessThan?.$case) {
      case "lt":
        writer.uint32(17).double(message.lessThan.lt);
        break;
      case "lte":
        writer.uint32(25).double(message.lessThan.lte);
        break;
    }
    switch (message.greaterThan?.$case) {
      case "gt":
        writer.uint32(33).double(message.greaterThan.gt);
        break;
      case "gte":
        writer.uint32(41).double(message.greaterThan.gte);
        break;
    }
    writer.uint32(50).fork();
    for (const v of message.in) {
      writer.double(v);
    }
    writer.join();
    writer.uint32(58).fork();
    for (const v of message.notIn) {
      writer.double(v);
    }
    writer.join();
    if (message.finite !== undefined && message.finite !== false) {
      writer.uint32(64).bool(message.finite);
    }
    writer.uint32(74).fork();
    for (const v of message.example) {
      writer.double(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): DoubleRules {
    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.lessThan = { $case: "lt", lt: reader.double() };
          continue;
        }
        case 3: {
          if (tag !== 25) {
            break;
          }

          message.lessThan = { $case: "lte", lte: reader.double() };
          continue;
        }
        case 4: {
          if (tag !== 33) {
            break;
          }

          message.greaterThan = { $case: "gt", gt: reader.double() };
          continue;
        }
        case 5: {
          if (tag !== 41) {
            break;
          }

          message.greaterThan = { $case: "gte", 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;
  },
};

function createBaseInt32Rules(): Int32Rules {
  return {
    const: 0,
    lessThan: undefined,
    greaterThan: undefined,
    in: [],
    notIn: [],
    example: [],
  };
}

export const Int32Rules: MessageFns<Int32Rules> = {
  encode(
    message: Int32Rules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.const !== undefined && message.const !== 0) {
      writer.uint32(8).int32(message.const);
    }
    switch (message.lessThan?.$case) {
      case "lt":
        writer.uint32(16).int32(message.lessThan.lt);
        break;
      case "lte":
        writer.uint32(24).int32(message.lessThan.lte);
        break;
    }
    switch (message.greaterThan?.$case) {
      case "gt":
        writer.uint32(32).int32(message.greaterThan.gt);
        break;
      case "gte":
        writer.uint32(40).int32(message.greaterThan.gte);
        break;
    }
    writer.uint32(50).fork();
    for (const v of message.in) {
      writer.int32(v);
    }
    writer.join();
    writer.uint32(58).fork();
    for (const v of message.notIn) {
      writer.int32(v);
    }
    writer.join();
    writer.uint32(66).fork();
    for (const v of message.example) {
      writer.int32(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): Int32Rules {
    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.lessThan = { $case: "lt", lt: reader.int32() };
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.lessThan = { $case: "lte", lte: reader.int32() };
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.greaterThan = { $case: "gt", gt: reader.int32() };
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.greaterThan = { $case: "gte", 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;
  },
};

function createBaseInt64Rules(): Int64Rules {
  return {
    const: "0",
    lessThan: undefined,
    greaterThan: undefined,
    in: [],
    notIn: [],
    example: [],
  };
}

export const Int64Rules: MessageFns<Int64Rules> = {
  encode(
    message: Int64Rules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.const !== undefined && message.const !== "0") {
      writer.uint32(8).int64(message.const);
    }
    switch (message.lessThan?.$case) {
      case "lt":
        writer.uint32(16).int64(message.lessThan.lt);
        break;
      case "lte":
        writer.uint32(24).int64(message.lessThan.lte);
        break;
    }
    switch (message.greaterThan?.$case) {
      case "gt":
        writer.uint32(32).int64(message.greaterThan.gt);
        break;
      case "gte":
        writer.uint32(40).int64(message.greaterThan.gte);
        break;
    }
    writer.uint32(50).fork();
    for (const v of message.in) {
      writer.int64(v);
    }
    writer.join();
    writer.uint32(58).fork();
    for (const v of message.notIn) {
      writer.int64(v);
    }
    writer.join();
    writer.uint32(74).fork();
    for (const v of message.example) {
      writer.int64(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): Int64Rules {
    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 = reader.int64().toString();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.lessThan = { $case: "lt", lt: reader.int64().toString() };
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.lessThan = { $case: "lte", lte: reader.int64().toString() };
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.greaterThan = { $case: "gt", gt: reader.int64().toString() };
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.greaterThan = {
            $case: "gte",
            gte: reader.int64().toString(),
          };
          continue;
        }
        case 6: {
          if (tag === 48) {
            message.in.push(reader.int64().toString());

            continue;
          }

          if (tag === 50) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.in.push(reader.int64().toString());
            }

            continue;
          }

          break;
        }
        case 7: {
          if (tag === 56) {
            message.notIn.push(reader.int64().toString());

            continue;
          }

          if (tag === 58) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.notIn.push(reader.int64().toString());
            }

            continue;
          }

          break;
        }
        case 9: {
          if (tag === 72) {
            message.example.push(reader.int64().toString());

            continue;
          }

          if (tag === 74) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.example.push(reader.int64().toString());
            }

            continue;
          }

          break;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseUInt32Rules(): UInt32Rules {
  return {
    const: 0,
    lessThan: undefined,
    greaterThan: undefined,
    in: [],
    notIn: [],
    example: [],
  };
}

export const UInt32Rules: MessageFns<UInt32Rules> = {
  encode(
    message: UInt32Rules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.const !== undefined && message.const !== 0) {
      writer.uint32(8).uint32(message.const);
    }
    switch (message.lessThan?.$case) {
      case "lt":
        writer.uint32(16).uint32(message.lessThan.lt);
        break;
      case "lte":
        writer.uint32(24).uint32(message.lessThan.lte);
        break;
    }
    switch (message.greaterThan?.$case) {
      case "gt":
        writer.uint32(32).uint32(message.greaterThan.gt);
        break;
      case "gte":
        writer.uint32(40).uint32(message.greaterThan.gte);
        break;
    }
    writer.uint32(50).fork();
    for (const v of message.in) {
      writer.uint32(v);
    }
    writer.join();
    writer.uint32(58).fork();
    for (const v of message.notIn) {
      writer.uint32(v);
    }
    writer.join();
    writer.uint32(66).fork();
    for (const v of message.example) {
      writer.uint32(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): UInt32Rules {
    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.lessThan = { $case: "lt", lt: reader.uint32() };
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.lessThan = { $case: "lte", lte: reader.uint32() };
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.greaterThan = { $case: "gt", gt: reader.uint32() };
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.greaterThan = { $case: "gte", 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;
  },
};

function createBaseUInt64Rules(): UInt64Rules {
  return {
    const: "0",
    lessThan: undefined,
    greaterThan: undefined,
    in: [],
    notIn: [],
    example: [],
  };
}

export const UInt64Rules: MessageFns<UInt64Rules> = {
  encode(
    message: UInt64Rules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.const !== undefined && message.const !== "0") {
      writer.uint32(8).uint64(message.const);
    }
    switch (message.lessThan?.$case) {
      case "lt":
        writer.uint32(16).uint64(message.lessThan.lt);
        break;
      case "lte":
        writer.uint32(24).uint64(message.lessThan.lte);
        break;
    }
    switch (message.greaterThan?.$case) {
      case "gt":
        writer.uint32(32).uint64(message.greaterThan.gt);
        break;
      case "gte":
        writer.uint32(40).uint64(message.greaterThan.gte);
        break;
    }
    writer.uint32(50).fork();
    for (const v of message.in) {
      writer.uint64(v);
    }
    writer.join();
    writer.uint32(58).fork();
    for (const v of message.notIn) {
      writer.uint64(v);
    }
    writer.join();
    writer.uint32(66).fork();
    for (const v of message.example) {
      writer.uint64(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): UInt64Rules {
    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 = reader.uint64().toString();
          continue;
        }
        case 2: {
          if (tag !== 16) {
            break;
          }

          message.lessThan = { $case: "lt", lt: reader.uint64().toString() };
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.lessThan = { $case: "lte", lte: reader.uint64().toString() };
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.greaterThan = { $case: "gt", gt: reader.uint64().toString() };
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.greaterThan = {
            $case: "gte",
            gte: reader.uint64().toString(),
          };
          continue;
        }
        case 6: {
          if (tag === 48) {
            message.in.push(reader.uint64().toString());

            continue;
          }

          if (tag === 50) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.in.push(reader.uint64().toString());
            }

            continue;
          }

          break;
        }
        case 7: {
          if (tag === 56) {
            message.notIn.push(reader.uint64().toString());

            continue;
          }

          if (tag === 58) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.notIn.push(reader.uint64().toString());
            }

            continue;
          }

          break;
        }
        case 8: {
          if (tag === 64) {
            message.example.push(reader.uint64().toString());

            continue;
          }

          if (tag === 66) {
            const end2 = reader.uint32() + reader.pos;
            while (reader.pos < end2) {
              message.example.push(reader.uint64().toString());
            }

            continue;
          }

          break;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
};

function createBaseSInt32Rules(): SInt32Rules {
  return {
    const: 0,
    lessThan: undefined,
    greaterThan: undefined,
    in: [],
    notIn: [],
    example: [],
  };
}

export const SInt32Rules: MessageFns<SInt32Rules> = {
  encode(
    message: SInt32Rules,
    writer: BinaryWriter = new BinaryWriter(),
  ): BinaryWriter {
    if (message.const !== undefined && message.const !== 0) {
      writer.uint32(8).sint32(message.const);
    }
    switch (message.lessThan?.$case) {
      case "lt":
        writer.uint32(16).sint32(message.lessThan.lt);
        break;
      case "lte":
        writer.uint32(24).sint32(message.lessThan.lte);
        break;
    }
    switch (message.greaterThan?.$case) {
      case "gt":
        writer.uint32(32).sint32(message.greaterThan.gt);
        break;
      case "gte":
        writer.uint32(40).sint32(message.greaterThan.gte);
        break;
    }
    writer.uint32(50).fork();
    for (const v of message.in) {
      writer.sint32(v);
    }
    writer.join();
    writer.uint32(58).fork();
    for (const v of message.notIn) {
      writer.sint32(v);
    }
    writer.join();
    writer.uint32(66).fork();
    for (const v of message.example) {
      writer.sint32(v);
    }
    writer.join();
    return writer;
  },

  decode(input: BinaryReader | Uint8Array, length?: number): SInt32Rules {
    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.lessThan = { $case: "lt", lt: reader.sint32() };
          continue;
        }
        case 3: {
          if (tag !== 24) {
            break;
          }

          message.lessThan = { $case: "lte", lte: reader.sint32() };
          continue;
        }
        case 4: {
          if (tag !== 32) {
            break;
          }

          message.greaterThan = { $case: "gt", gt: reader.sint32() };
          continue;
        }
        case 5: {
          if (tag !== 40) {
            break;
          }

          message.greaterThan = { $case: "gte", gte: reader.sint32() };