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

Load Cerbos policies from YAML or JSON files

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

/* eslint-disable */
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 function ignoreFromJSON(object: any): Ignore {
  switch (object) {
    case 0:
    case "IGNORE_UNSPECIFIED":
      return Ignore.IGNORE_UNSPECIFIED;
    case 1:
    case "IGNORE_IF_UNPOPULATED":
      return Ignore.IGNORE_IF_UNPOPULATED;
    case 2:
    case "IGNORE_IF_DEFAULT_VALUE":
      return Ignore.IGNORE_IF_DEFAULT_VALUE;
    case 3:
    case "IGNORE_ALWAYS":
      return Ignore.IGNORE_ALWAYS;
    default:
      throw new globalThis.Error(
        "Unrecognized enum value " + object + " for enum Ignore",
      );
  }
}

export function ignoreToJSON(object: Ignore): string {
  switch (object) {
    case Ignore.IGNORE_UNSPECIFIED:
      return "IGNORE_UNSPECIFIED";
    case Ignore.IGNORE_IF_UNPOPULATED:
      return "IGNORE_IF_UNPOPULATED";
    case Ignore.IGNORE_IF_DEFAULT_VALUE:
      return "IGNORE_IF_DEFAULT_VALUE";
    case Ignore.IGNORE_ALWAYS:
      return "IGNORE_ALWAYS";
    default:
      throw new globalThis.Error(
        "Unrecognized enum value " + object + " for enum Ignore",
      );
  }
}

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

export function knownRegexFromJSON(object: any): KnownRegex {
  switch (object) {
    case 0:
    case "KNOWN_REGEX_UNSPECIFIED":
      return KnownRegex.KNOWN_REGEX_UNSPECIFIED;
    case 1:
    case "KNOWN_REGEX_HTTP_HEADER_NAME":
      return KnownRegex.KNOWN_REGEX_HTTP_HEADER_NAME;
    case 2:
    case "KNOWN_REGEX_HTTP_HEADER_VALUE":
      return KnownRegex.KNOWN_REGEX_HTTP_HEADER_VALUE;
    default:
      throw new globalThis.Error(
        "Unrecognized enum value " + object + " for enum KnownRegex",
      );
  }
}

export function knownRegexToJSON(object: KnownRegex): string {
  switch (object) {
    case KnownRegex.KNOWN_REGEX_UNSPECIFIED:
      return "KNOWN_REGEX_UNSPECIFIED";
    case KnownRegex.KNOWN_REGEX_HTTP_HEADER_NAME:
      return "KNOWN_REGEX_HTTP_HEADER_NAME";
    case KnownRegex.KNOWN_REGEX_HTTP_HEADER_VALUE:
      return "KNOWN_REGEX_HTTP_HEADER_VALUE";
    default:
      throw new globalThis.Error(
        "Unrecognized enum value " + object + " for enum KnownRegex",
      );
  }
}

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

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[];
}

export const Rule: MessageFns<Rule> = {
  fromJSON(object: any): Rule {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      message: isSet(object.message) ? globalThis.String(object.message) : "",
      expression: isSet(object.expression)
        ? globalThis.String(object.expression)
        : "",
    };
  },

  toJSON(message: Rule): unknown {
    const obj: any = {};
    if (message.id !== undefined && message.id !== "") {
      obj.id = message.id;
    }
    if (message.message !== undefined && message.message !== "") {
      obj.message = message.message;
    }
    if (message.expression !== undefined && message.expression !== "") {
      obj.expression = message.expression;
    }
    return obj;
  },
};

export const OneofRules: MessageFns<OneofRules> = {
  fromJSON(object: any): OneofRules {
    return {
      required: isSet(object.required)
        ? globalThis.Boolean(object.required)
        : false,
    };
  },

  toJSON(message: OneofRules): unknown {
    const obj: any = {};
    if (message.required !== undefined && message.required !== false) {
      obj.required = message.required;
    }
    return obj;
  },
};

export const FieldRules: MessageFns<FieldRules> = {
  fromJSON(object: any): FieldRules {
    return {
      cel: globalThis.Array.isArray(object?.cel)
        ? object.cel.map((e: any) => Rule.fromJSON(e))
        : [],
      required: isSet(object.required)
        ? globalThis.Boolean(object.required)
        : false,
      ignore: isSet(object.ignore) ? ignoreFromJSON(object.ignore) : 0,
      type: isSet(object.float)
        ? { $case: "float", float: FloatRules.fromJSON(object.float) }
        : isSet(object.double)
          ? { $case: "double", double: DoubleRules.fromJSON(object.double) }
          : isSet(object.int32)
            ? { $case: "int32", int32: Int32Rules.fromJSON(object.int32) }
            : isSet(object.int64)
              ? { $case: "int64", int64: Int64Rules.fromJSON(object.int64) }
              : isSet(object.uint32)
                ? {
                    $case: "uint32",
                    uint32: UInt32Rules.fromJSON(object.uint32),
                  }
                : isSet(object.uint64)
                  ? {
                      $case: "uint64",
                      uint64: UInt64Rules.fromJSON(object.uint64),
                    }
                  : isSet(object.sint32)
                    ? {
                        $case: "sint32",
                        sint32: SInt32Rules.fromJSON(object.sint32),
                      }
                    : isSet(object.sint64)
                      ? {
                          $case: "sint64",
                          sint64: SInt64Rules.fromJSON(object.sint64),
                        }
                      : isSet(object.fixed32)
                        ? {
                            $case: "fixed32",
                            fixed32: Fixed32Rules.fromJSON(object.fixed32),
                          }
                        : isSet(object.fixed64)
                          ? {
                              $case: "fixed64",
                              fixed64: Fixed64Rules.fromJSON(object.fixed64),
                            }
                          : isSet(object.sfixed32)
                            ? {
                                $case: "sfixed32",
                                sfixed32: SFixed32Rules.fromJSON(
                                  object.sfixed32,
                                ),
                              }
                            : isSet(object.sfixed64)
                              ? {
                                  $case: "sfixed64",
                                  sfixed64: SFixed64Rules.fromJSON(
                                    object.sfixed64,
                                  ),
                                }
                              : isSet(object.bool)
                                ? {
                                    $case: "bool",
                                    bool: BoolRules.fromJSON(object.bool),
                                  }
                                : isSet(object.string)
                                  ? {
                                      $case: "string",
                                      string: StringRules.fromJSON(
                                        object.string,
                                      ),
                                    }
                                  : isSet(object.bytes)
                                    ? {
                                        $case: "bytes",
                                        bytes: BytesRules.fromJSON(
                                          object.bytes,
                                        ),
                                      }
                                    : isSet(object.enum)
                                      ? {
                                          $case: "enum",
                                          enum: EnumRules.fromJSON(object.enum),
                                        }
                                      : isSet(object.repeated)
                                        ? {
                                            $case: "repeated",
                                            repeated: RepeatedRules.fromJSON(
                                              object.repeated,
                                            ),
                                          }
                                        : isSet(object.map)
                                          ? {
                                              $case: "map",
                                              map: MapRules.fromJSON(
                                                object.map,
                                              ),
                                            }
                                          : isSet(object.any)
                                            ? {
                                                $case: "any",
                                                any: AnyRules.fromJSON(
                                                  object.any,
                                                ),
                                              }
                                            : isSet(object.duration)
                                              ? {
                                                  $case: "duration",
                                                  duration:
                                                    DurationRules.fromJSON(
                                                      object.duration,
                                                    ),
                                                }
                                              : isSet(object.timestamp)
                                                ? {
                                                    $case: "timestamp",
                                                    timestamp:
                                                      TimestampRules.fromJSON(
                                                        object.timestamp,
                                                      ),
                                                  }
                                                : undefined,
    };
  },

  toJSON(message: FieldRules): unknown {
    const obj: any = {};
    if (message.cel?.length) {
      obj.cel = message.cel.map((e) => Rule.toJSON(e));
    }
    if (message.required !== undefined && message.required !== false) {
      obj.required = message.required;
    }
    if (message.ignore !== undefined && message.ignore !== 0) {
      obj.ignore = ignoreToJSON(message.ignore);
    }
    if (message.type?.$case === "float") {
      obj.float = FloatRules.toJSON(message.type.float);
    } else if (message.type?.$case === "double") {
      obj.double = DoubleRules.toJSON(message.type.double);
    } else if (message.type?.$case === "int32") {
      obj.int32 = Int32Rules.toJSON(message.type.int32);
    } else if (message.type?.$case === "int64") {
      obj.int64 = Int64Rules.toJSON(message.type.int64);
    } else if (message.type?.$case === "uint32") {
      obj.uint32 = UInt32Rules.toJSON(message.type.uint32);
    } else if (message.type?.$case === "uint64") {
      obj.uint64 = UInt64Rules.toJSON(message.type.uint64);
    } else if (message.type?.$case === "sint32") {
      obj.sint32 = SInt32Rules.toJSON(message.type.sint32);
    } else if (message.type?.$case === "sint64") {
      obj.sint64 = SInt64Rules.toJSON(message.type.sint64);
    } else if (message.type?.$case === "fixed32") {
      obj.fixed32 = Fixed32Rules.toJSON(message.type.fixed32);
    } else if (message.type?.$case === "fixed64") {
      obj.fixed64 = Fixed64Rules.toJSON(message.type.fixed64);
    } else if (message.type?.$case === "sfixed32") {
      obj.sfixed32 = SFixed32Rules.toJSON(message.type.sfixed32);
    } else if (message.type?.$case === "sfixed64") {
      obj.sfixed64 = SFixed64Rules.toJSON(message.type.sfixed64);
    } else if (message.type?.$case === "bool") {
      obj.bool = BoolRules.toJSON(message.type.bool);
    } else if (message.type?.$case === "string") {
      obj.string = StringRules.toJSON(message.type.string);
    } else if (message.type?.$case === "bytes") {
      obj.bytes = BytesRules.toJSON(message.type.bytes);
    } else if (message.type?.$case === "enum") {
      obj.enum = EnumRules.toJSON(message.type.enum);
    } else if (message.type?.$case === "repeated") {
      obj.repeated = RepeatedRules.toJSON(message.type.repeated);
    } else if (message.type?.$case === "map") {
      obj.map = MapRules.toJSON(message.type.map);
    } else if (message.type?.$case === "any") {
      obj.any = AnyRules.toJSON(message.type.any);
    } else if (message.type?.$case === "duration") {
      obj.duration = DurationRules.toJSON(message.type.duration);
    } else if (message.type?.$case === "timestamp") {
      obj.timestamp = TimestampRules.toJSON(message.type.timestamp);
    }
    return obj;
  },
};

export const PredefinedRules: MessageFns<PredefinedRules> = {
  fromJSON(object: any): PredefinedRules {
    return {
      cel: globalThis.Array.isArray(object?.cel)
        ? object.cel.map((e: any) => Rule.fromJSON(e))
        : [],
    };
  },

  toJSON(message: PredefinedRules): unknown {
    const obj: any = {};
    if (message.cel?.length) {
      obj.cel = message.cel.map((e) => Rule.toJSON(e));
    }
    return obj;
  },
};

export const FloatRules: MessageFns<FloatRules> = {
  fromJSON(object: any): FloatRules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.Number(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.Number(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.Number(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.Number(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.Number(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.Number(e))
        : [],
      finite: isSet(object.finite) ? globalThis.Boolean(object.finite) : false,
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: FloatRules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = message.const;
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt;
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt;
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.finite !== undefined && message.finite !== false) {
      obj.finite = message.finite;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const DoubleRules: MessageFns<DoubleRules> = {
  fromJSON(object: any): DoubleRules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.Number(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.Number(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.Number(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.Number(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.Number(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.Number(e))
        : [],
      finite: isSet(object.finite) ? globalThis.Boolean(object.finite) : false,
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: DoubleRules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = message.const;
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt;
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt;
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.finite !== undefined && message.finite !== false) {
      obj.finite = message.finite;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const Int32Rules: MessageFns<Int32Rules> = {
  fromJSON(object: any): Int32Rules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.Number(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.Number(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.Number(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.Number(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.Number(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.Number(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: Int32Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = Math.round(message.const);
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = Math.round(message.lessThan.lt);
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = Math.round(message.lessThan.lte);
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = Math.round(message.greaterThan.gt);
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = Math.round(message.greaterThan.gte);
    }
    if (message.in?.length) {
      obj.in = message.in.map((e) => Math.round(e));
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn.map((e) => Math.round(e));
    }
    if (message.example?.length) {
      obj.example = message.example.map((e) => Math.round(e));
    }
    return obj;
  },
};

export const Int64Rules: MessageFns<Int64Rules> = {
  fromJSON(object: any): Int64Rules {
    return {
      const: isSet(object.const) ? globalThis.String(object.const) : "0",
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.String(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.String(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.String(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.String(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.String(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.String(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: Int64Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== "0") {
      obj.const = message.const;
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt;
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt;
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const UInt32Rules: MessageFns<UInt32Rules> = {
  fromJSON(object: any): UInt32Rules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.Number(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.Number(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.Number(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.Number(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.Number(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.Number(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: UInt32Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = Math.round(message.const);
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = Math.round(message.lessThan.lt);
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = Math.round(message.lessThan.lte);
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = Math.round(message.greaterThan.gt);
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = Math.round(message.greaterThan.gte);
    }
    if (message.in?.length) {
      obj.in = message.in.map((e) => Math.round(e));
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn.map((e) => Math.round(e));
    }
    if (message.example?.length) {
      obj.example = message.example.map((e) => Math.round(e));
    }
    return obj;
  },
};

export const UInt64Rules: MessageFns<UInt64Rules> = {
  fromJSON(object: any): UInt64Rules {
    return {
      const: isSet(object.const) ? globalThis.String(object.const) : "0",
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.String(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.String(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.String(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.String(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.String(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.String(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: UInt64Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== "0") {
      obj.const = message.const;
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt;
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt;
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const SInt32Rules: MessageFns<SInt32Rules> = {
  fromJSON(object: any): SInt32Rules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.Number(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.Number(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.Number(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.Number(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.Number(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.Number(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: SInt32Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = Math.round(message.const);
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = Math.round(message.lessThan.lt);
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = Math.round(message.lessThan.lte);
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = Math.round(message.greaterThan.gt);
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = Math.round(message.greaterThan.gte);
    }
    if (message.in?.length) {
      obj.in = message.in.map((e) => Math.round(e));
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn.map((e) => Math.round(e));
    }
    if (message.example?.length) {
      obj.example = message.example.map((e) => Math.round(e));
    }
    return obj;
  },
};

export const SInt64Rules: MessageFns<SInt64Rules> = {
  fromJSON(object: any): SInt64Rules {
    return {
      const: isSet(object.const) ? globalThis.String(object.const) : "0",
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.String(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.String(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.String(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.String(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.String(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.String(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: SInt64Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== "0") {
      obj.const = message.const;
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt;
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt;
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const Fixed32Rules: MessageFns<Fixed32Rules> = {
  fromJSON(object: any): Fixed32Rules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.Number(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.Number(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.Number(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.Number(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.Number(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.Number(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: Fixed32Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = Math.round(message.const);
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = Math.round(message.lessThan.lt);
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = Math.round(message.lessThan.lte);
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = Math.round(message.greaterThan.gt);
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = Math.round(message.greaterThan.gte);
    }
    if (message.in?.length) {
      obj.in = message.in.map((e) => Math.round(e));
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn.map((e) => Math.round(e));
    }
    if (message.example?.length) {
      obj.example = message.example.map((e) => Math.round(e));
    }
    return obj;
  },
};

export const Fixed64Rules: MessageFns<Fixed64Rules> = {
  fromJSON(object: any): Fixed64Rules {
    return {
      const: isSet(object.const) ? globalThis.String(object.const) : "0",
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.String(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.String(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.String(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.String(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.String(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.String(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: Fixed64Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== "0") {
      obj.const = message.const;
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt;
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt;
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const SFixed32Rules: MessageFns<SFixed32Rules> = {
  fromJSON(object: any): SFixed32Rules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.Number(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.Number(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.Number(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.Number(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.Number(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.Number(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Number(e))
        : [],
    };
  },

  toJSON(message: SFixed32Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = Math.round(message.const);
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = Math.round(message.lessThan.lt);
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = Math.round(message.lessThan.lte);
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = Math.round(message.greaterThan.gt);
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = Math.round(message.greaterThan.gte);
    }
    if (message.in?.length) {
      obj.in = message.in.map((e) => Math.round(e));
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn.map((e) => Math.round(e));
    }
    if (message.example?.length) {
      obj.example = message.example.map((e) => Math.round(e));
    }
    return obj;
  },
};

export const SFixed64Rules: MessageFns<SFixed64Rules> = {
  fromJSON(object: any): SFixed64Rules {
    return {
      const: isSet(object.const) ? globalThis.String(object.const) : "0",
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: globalThis.String(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: globalThis.String(object.lte) }
          : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: globalThis.String(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: globalThis.String(object.gte) }
          : undefined,
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.String(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.String(e))
        : [],
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: SFixed64Rules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== "0") {
      obj.const = message.const;
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt;
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt;
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const BoolRules: MessageFns<BoolRules> = {
  fromJSON(object: any): BoolRules {
    return {
      const: isSet(object.const) ? globalThis.Boolean(object.const) : false,
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.Boolean(e))
        : [],
    };
  },

  toJSON(message: BoolRules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== false) {
      obj.const = message.const;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const StringRules: MessageFns<StringRules> = {
  fromJSON(object: any): StringRules {
    return {
      const: isSet(object.const) ? globalThis.String(object.const) : "",
      len: isSet(object.len) ? globalThis.String(object.len) : "0",
      minLen: isSet(object.minLen) ? globalThis.String(object.minLen) : "0",
      maxLen: isSet(object.maxLen) ? globalThis.String(object.maxLen) : "0",
      lenBytes: isSet(object.lenBytes)
        ? globalThis.String(object.lenBytes)
        : "0",
      minBytes: isSet(object.minBytes)
        ? globalThis.String(object.minBytes)
        : "0",
      maxBytes: isSet(object.maxBytes)
        ? globalThis.String(object.maxBytes)
        : "0",
      pattern: isSet(object.pattern) ? globalThis.String(object.pattern) : "",
      prefix: isSet(object.prefix) ? globalThis.String(object.prefix) : "",
      suffix: isSet(object.suffix) ? globalThis.String(object.suffix) : "",
      contains: isSet(object.contains)
        ? globalThis.String(object.contains)
        : "",
      notContains: isSet(object.notContains)
        ? globalThis.String(object.notContains)
        : "",
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => globalThis.String(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => globalThis.String(e))
        : [],
      wellKnown: isSet(object.email)
        ? { $case: "email", email: globalThis.Boolean(object.email) }
        : isSet(object.hostname)
          ? { $case: "hostname", hostname: globalThis.Boolean(object.hostname) }
          : isSet(object.ip)
            ? { $case: "ip", ip: globalThis.Boolean(object.ip) }
            : isSet(object.ipv4)
              ? { $case: "ipv4", ipv4: globalThis.Boolean(object.ipv4) }
              : isSet(object.ipv6)
                ? { $case: "ipv6", ipv6: globalThis.Boolean(object.ipv6) }
                : isSet(object.uri)
                  ? { $case: "uri", uri: globalThis.Boolean(object.uri) }
                  : isSet(object.uriRef)
                    ? {
                        $case: "uriRef",
                        uriRef: globalThis.Boolean(object.uriRef),
                      }
                    : isSet(object.address)
                      ? {
                          $case: "address",
                          address: globalThis.Boolean(object.address),
                        }
                      : isSet(object.uuid)
                        ? {
                            $case: "uuid",
                            uuid: globalThis.Boolean(object.uuid),
                          }
                        : isSet(object.tuuid)
                          ? {
                              $case: "tuuid",
                              tuuid: globalThis.Boolean(object.tuuid),
                            }
                          : isSet(object.ipWithPrefixlen)
                            ? {
                                $case: "ipWithPrefixlen",
                                ipWithPrefixlen: globalThis.Boolean(
                                  object.ipWithPrefixlen,
                                ),
                              }
                            : isSet(object.ipv4WithPrefixlen)
                              ? {
                                  $case: "ipv4WithPrefixlen",
                                  ipv4WithPrefixlen: globalThis.Boolean(
                                    object.ipv4WithPrefixlen,
                                  ),
                                }
                              : isSet(object.ipv6WithPrefixlen)
                                ? {
                                    $case: "ipv6WithPrefixlen",
                                    ipv6WithPrefixlen: globalThis.Boolean(
                                      object.ipv6WithPrefixlen,
                                    ),
                                  }
                                : isSet(object.ipPrefix)
                                  ? {
                                      $case: "ipPrefix",
                                      ipPrefix: globalThis.Boolean(
                                        object.ipPrefix,
                                      ),
                                    }
                                  : isSet(object.ipv4Prefix)
                                    ? {
                                        $case: "ipv4Prefix",
                                        ipv4Prefix: globalThis.Boolean(
                                          object.ipv4Prefix,
                                        ),
                                      }
                                    : isSet(object.ipv6Prefix)
                                      ? {
                                          $case: "ipv6Prefix",
                                          ipv6Prefix: globalThis.Boolean(
                                            object.ipv6Prefix,
                                          ),
                                        }
                                      : isSet(object.hostAndPort)
                                        ? {
                                            $case: "hostAndPort",
                                            hostAndPort: globalThis.Boolean(