// 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,
  IGNORE_EMPTY = 1,
  IGNORE_DEFAULT = 2,
}

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;
    case 1:
    case "IGNORE_EMPTY":
      return Ignore.IGNORE_EMPTY;
    case 2:
    case "IGNORE_DEFAULT":
      return Ignore.IGNORE_DEFAULT;
    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";
    case Ignore.IGNORE_EMPTY:
      return "IGNORE_EMPTY";
    case Ignore.IGNORE_DEFAULT:
      return "IGNORE_DEFAULT";
    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 Constraint {
  id?: string | undefined;
  message?: string | undefined;
  expression?: string | undefined;
}

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

export interface FieldConstraints {
  cel: Constraint[];
  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;
  skipped?: boolean | undefined;
  ignoreEmpty?: boolean | undefined;
}

export interface PredefinedConstraints {
  cel: Constraint[];
}

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?: FieldConstraints | undefined;
}

export interface MapRules {
  minPairs?: string | undefined;
  maxPairs?: string | undefined;
  keys?: FieldConstraints | undefined;
  values?: FieldConstraints | 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 Constraint: MessageFns<Constraint> = {
  fromJSON(object: any): Constraint {
    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: Constraint): 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 OneofConstraints: MessageFns<OneofConstraints> = {
  fromJSON(object: any): OneofConstraints {
    return {
      required: isSet(object.required)
        ? globalThis.Boolean(object.required)
        : false,
    };
  },

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

export const FieldConstraints: MessageFns<FieldConstraints> = {
  fromJSON(object: any): FieldConstraints {
    return {
      cel: globalThis.Array.isArray(object?.cel)
        ? object.cel.map((e: any) => Constraint.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,
      skipped: isSet(object.skipped)
        ? globalThis.Boolean(object.skipped)
        : false,
      ignoreEmpty: isSet(object.ignoreEmpty)
        ? globalThis.Boolean(object.ignoreEmpty)
        : false,
    };
  },

  toJSON(message: FieldConstraints): unknown {
    const obj: any = {};
    if (message.cel?.length) {
      obj.cel = message.cel.map((e) => Constraint.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);
    }
    if (message.skipped !== undefined && message.skipped !== false) {
      obj.skipped = message.skipped;
    }
    if (message.ignoreEmpty !== undefined && message.ignoreEmpty !== false) {
      obj.ignoreEmpty = message.ignoreEmpty;
    }
    return obj;
  },
};

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

  toJSON(message: PredefinedConstraints): unknown {
    const obj: any = {};
    if (message.cel?.length) {
      obj.cel = message.cel.map((e) => Constraint.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(
                                              object.hostAndPort,
                                            ),
                                          }
                                        : isSet(object.wellKnownRegex)
                                          ? {
                                              $case: "wellKnownRegex",
                                              wellKnownRegex:
                                                knownRegexFromJSON(
                                                  object.wellKnownRegex,
                                                ),
                                            }
                                          : undefined,
      strict: isSet(object.strict) ? globalThis.Boolean(object.strict) : false,
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => globalThis.String(e))
        : [],
    };
  },

  toJSON(message: StringRules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== "") {
      obj.const = message.const;
    }
    if (message.len !== undefined && message.len !== "0") {
      obj.len = message.len;
    }
    if (message.minLen !== undefined && message.minLen !== "0") {
      obj.minLen = message.minLen;
    }
    if (message.maxLen !== undefined && message.maxLen !== "0") {
      obj.maxLen = message.maxLen;
    }
    if (message.lenBytes !== undefined && message.lenBytes !== "0") {
      obj.lenBytes = message.lenBytes;
    }
    if (message.minBytes !== undefined && message.minBytes !== "0") {
      obj.minBytes = message.minBytes;
    }
    if (message.maxBytes !== undefined && message.maxBytes !== "0") {
      obj.maxBytes = message.maxBytes;
    }
    if (message.pattern !== undefined && message.pattern !== "") {
      obj.pattern = message.pattern;
    }
    if (message.prefix !== undefined && message.prefix !== "") {
      obj.prefix = message.prefix;
    }
    if (message.suffix !== undefined && message.suffix !== "") {
      obj.suffix = message.suffix;
    }
    if (message.contains !== undefined && message.contains !== "") {
      obj.contains = message.contains;
    }
    if (message.notContains !== undefined && message.notContains !== "") {
      obj.notContains = message.notContains;
    }
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    if (message.wellKnown?.$case === "email") {
      obj.email = message.wellKnown.email;
    } else if (message.wellKnown?.$case === "hostname") {
      obj.hostname = message.wellKnown.hostname;
    } else if (message.wellKnown?.$case === "ip") {
      obj.ip = message.wellKnown.ip;
    } else if (message.wellKnown?.$case === "ipv4") {
      obj.ipv4 = message.wellKnown.ipv4;
    } else if (message.wellKnown?.$case === "ipv6") {
      obj.ipv6 = message.wellKnown.ipv6;
    } else if (message.wellKnown?.$case === "uri") {
      obj.uri = message.wellKnown.uri;
    } else if (message.wellKnown?.$case === "uriRef") {
      obj.uriRef = message.wellKnown.uriRef;
    } else if (message.wellKnown?.$case === "address") {
      obj.address = message.wellKnown.address;
    } else if (message.wellKnown?.$case === "uuid") {
      obj.uuid = message.wellKnown.uuid;
    } else if (message.wellKnown?.$case === "tuuid") {
      obj.tuuid = message.wellKnown.tuuid;
    } else if (message.wellKnown?.$case === "ipWithPrefixlen") {
      obj.ipWithPrefixlen = message.wellKnown.ipWithPrefixlen;
    } else if (message.wellKnown?.$case === "ipv4WithPrefixlen") {
      obj.ipv4WithPrefixlen = message.wellKnown.ipv4WithPrefixlen;
    } else if (message.wellKnown?.$case === "ipv6WithPrefixlen") {
      obj.ipv6WithPrefixlen = message.wellKnown.ipv6WithPrefixlen;
    } else if (message.wellKnown?.$case === "ipPrefix") {
      obj.ipPrefix = message.wellKnown.ipPrefix;
    } else if (message.wellKnown?.$case === "ipv4Prefix") {
      obj.ipv4Prefix = message.wellKnown.ipv4Prefix;
    } else if (message.wellKnown?.$case === "ipv6Prefix") {
      obj.ipv6Prefix = message.wellKnown.ipv6Prefix;
    } else if (message.wellKnown?.$case === "hostAndPort") {
      obj.hostAndPort = message.wellKnown.hostAndPort;
    } else if (message.wellKnown?.$case === "wellKnownRegex") {
      obj.wellKnownRegex = knownRegexToJSON(message.wellKnown.wellKnownRegex);
    }
    if (message.strict !== undefined && message.strict !== false) {
      obj.strict = message.strict;
    }
    if (message.example?.length) {
      obj.example = message.example;
    }
    return obj;
  },
};

export const BytesRules: MessageFns<BytesRules> = {
  fromJSON(object: any): BytesRules {
    return {
      const: isSet(object.const)
        ? bytesFromBase64(object.const)
        : new Uint8Array(0),
      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",
      pattern: isSet(object.pattern) ? globalThis.String(object.pattern) : "",
      prefix: isSet(object.prefix)
        ? bytesFromBase64(object.prefix)
        : new Uint8Array(0),
      suffix: isSet(object.suffix)
        ? bytesFromBase64(object.suffix)
        : new Uint8Array(0),
      contains: isSet(object.contains)
        ? bytesFromBase64(object.contains)
        : new Uint8Array(0),
      in: globalThis.Array.isArray(object?.in)
        ? object.in.map((e: any) => bytesFromBase64(e))
        : [],
      notIn: globalThis.Array.isArray(object?.notIn)
        ? object.notIn.map((e: any) => bytesFromBase64(e))
        : [],
      wellKnown: 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) }
            : undefined,
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => bytesFromBase64(e))
        : [],
    };
  },

  toJSON(message: BytesRules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const.length !== 0) {
      obj.const = base64FromBytes(message.const);
    }
    if (message.len !== undefined && message.len !== "0") {
      obj.len = message.len;
    }
    if (message.minLen !== undefined && message.minLen !== "0") {
      obj.minLen = message.minLen;
    }
    if (message.maxLen !== undefined && message.maxLen !== "0") {
      obj.maxLen = message.maxLen;
    }
    if (message.pattern !== undefined && message.pattern !== "") {
      obj.pattern = message.pattern;
    }
    if (message.prefix !== undefined && message.prefix.length !== 0) {
      obj.prefix = base64FromBytes(message.prefix);
    }
    if (message.suffix !== undefined && message.suffix.length !== 0) {
      obj.suffix = base64FromBytes(message.suffix);
    }
    if (message.contains !== undefined && message.contains.length !== 0) {
      obj.contains = base64FromBytes(message.contains);
    }
    if (message.in?.length) {
      obj.in = message.in.map((e) => base64FromBytes(e));
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn.map((e) => base64FromBytes(e));
    }
    if (message.wellKnown?.$case === "ip") {
      obj.ip = message.wellKnown.ip;
    } else if (message.wellKnown?.$case === "ipv4") {
      obj.ipv4 = message.wellKnown.ipv4;
    } else if (message.wellKnown?.$case === "ipv6") {
      obj.ipv6 = message.wellKnown.ipv6;
    }
    if (message.example?.length) {
      obj.example = message.example.map((e) => base64FromBytes(e));
    }
    return obj;
  },
};

export const EnumRules: MessageFns<EnumRules> = {
  fromJSON(object: any): EnumRules {
    return {
      const: isSet(object.const) ? globalThis.Number(object.const) : 0,
      definedOnly: isSet(object.definedOnly)
        ? globalThis.Boolean(object.definedOnly)
        : false,
      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: EnumRules): unknown {
    const obj: any = {};
    if (message.const !== undefined && message.const !== 0) {
      obj.const = Math.round(message.const);
    }
    if (message.definedOnly !== undefined && message.definedOnly !== false) {
      obj.definedOnly = message.definedOnly;
    }
    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 RepeatedRules: MessageFns<RepeatedRules> = {
  fromJSON(object: any): RepeatedRules {
    return {
      minItems: isSet(object.minItems)
        ? globalThis.String(object.minItems)
        : "0",
      maxItems: isSet(object.maxItems)
        ? globalThis.String(object.maxItems)
        : "0",
      unique: isSet(object.unique) ? globalThis.Boolean(object.unique) : false,
      items: isSet(object.items)
        ? FieldConstraints.fromJSON(object.items)
        : undefined,
    };
  },

  toJSON(message: RepeatedRules): unknown {
    const obj: any = {};
    if (message.minItems !== undefined && message.minItems !== "0") {
      obj.minItems = message.minItems;
    }
    if (message.maxItems !== undefined && message.maxItems !== "0") {
      obj.maxItems = message.maxItems;
    }
    if (message.unique !== undefined && message.unique !== false) {
      obj.unique = message.unique;
    }
    if (message.items !== undefined) {
      obj.items = FieldConstraints.toJSON(message.items);
    }
    return obj;
  },
};

export const MapRules: MessageFns<MapRules> = {
  fromJSON(object: any): MapRules {
    return {
      minPairs: isSet(object.minPairs)
        ? globalThis.String(object.minPairs)
        : "0",
      maxPairs: isSet(object.maxPairs)
        ? globalThis.String(object.maxPairs)
        : "0",
      keys: isSet(object.keys)
        ? FieldConstraints.fromJSON(object.keys)
        : undefined,
      values: isSet(object.values)
        ? FieldConstraints.fromJSON(object.values)
        : undefined,
    };
  },

  toJSON(message: MapRules): unknown {
    const obj: any = {};
    if (message.minPairs !== undefined && message.minPairs !== "0") {
      obj.minPairs = message.minPairs;
    }
    if (message.maxPairs !== undefined && message.maxPairs !== "0") {
      obj.maxPairs = message.maxPairs;
    }
    if (message.keys !== undefined) {
      obj.keys = FieldConstraints.toJSON(message.keys);
    }
    if (message.values !== undefined) {
      obj.values = FieldConstraints.toJSON(message.values);
    }
    return obj;
  },
};

export const AnyRules: MessageFns<AnyRules> = {
  fromJSON(object: any): AnyRules {
    return {
      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))
        : [],
    };
  },

  toJSON(message: AnyRules): unknown {
    const obj: any = {};
    if (message.in?.length) {
      obj.in = message.in;
    }
    if (message.notIn?.length) {
      obj.notIn = message.notIn;
    }
    return obj;
  },
};

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

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

export const TimestampRules: MessageFns<TimestampRules> = {
  fromJSON(object: any): TimestampRules {
    return {
      const: isSet(object.const) ? fromJsonTimestamp(object.const) : undefined,
      lessThan: isSet(object.lt)
        ? { $case: "lt", lt: fromJsonTimestamp(object.lt) }
        : isSet(object.lte)
          ? { $case: "lte", lte: fromJsonTimestamp(object.lte) }
          : isSet(object.ltNow)
            ? { $case: "ltNow", ltNow: globalThis.Boolean(object.ltNow) }
            : undefined,
      greaterThan: isSet(object.gt)
        ? { $case: "gt", gt: fromJsonTimestamp(object.gt) }
        : isSet(object.gte)
          ? { $case: "gte", gte: fromJsonTimestamp(object.gte) }
          : isSet(object.gtNow)
            ? { $case: "gtNow", gtNow: globalThis.Boolean(object.gtNow) }
            : undefined,
      within: isSet(object.within)
        ? Duration.fromJSON(object.within)
        : undefined,
      example: globalThis.Array.isArray(object?.example)
        ? object.example.map((e: any) => fromJsonTimestamp(e))
        : [],
    };
  },

  toJSON(message: TimestampRules): unknown {
    const obj: any = {};
    if (message.const !== undefined) {
      obj.const = message.const.toISOString();
    }
    if (message.lessThan?.$case === "lt") {
      obj.lt = message.lessThan.lt.toISOString();
    } else if (message.lessThan?.$case === "lte") {
      obj.lte = message.lessThan.lte.toISOString();
    } else if (message.lessThan?.$case === "ltNow") {
      obj.ltNow = message.lessThan.ltNow;
    }
    if (message.greaterThan?.$case === "gt") {
      obj.gt = message.greaterThan.gt.toISOString();
    } else if (message.greaterThan?.$case === "gte") {
      obj.gte = message.greaterThan.gte.toISOString();
    } else if (message.greaterThan?.$case === "gtNow") {
      obj.gtNow = message.greaterThan.gtNow;
    }
    if (message.within !== undefined) {
      obj.within = Duration.toJSON(message.within);
    }
    if (message.example?.length) {
      obj.example = message.example.map((e) => e.toISOString());
    }
    return obj;
  },
};

function bytesFromBase64(b64: string): Uint8Array {
  if ((globalThis as any).Buffer) {
    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
  } else {
    const bin = globalThis.atob(b64);
    const arr = new Uint8Array(bin.length);
    for (let i = 0; i < bin.length; ++i) {
      arr[i] = bin.charCodeAt(i);
    }
    return arr;
  }
}

function base64FromBytes(arr: Uint8Array): string {
  if ((globalThis as any).Buffer) {
    return globalThis.Buffer.from(arr).toString("base64");
  } else {
    const bin: string[] = [];
    arr.forEach((byte) => {
      bin.push(globalThis.String.fromCharCode(byte));
    });
    return globalThis.btoa(bin.join(""));
  }
}

function fromTimestamp(t: Timestamp): Date {
  let millis = (globalThis.Number(t.seconds) || 0) * 1_000;
  millis += (t.nanos || 0) / 1_000_000;
  return new globalThis.Date(millis);
}

function fromJsonTimestamp(o: any): Date {
  if (o instanceof globalThis.Date) {
    return o;
  } else if (typeof o === "string") {
    return new globalThis.Date(o);
  } else {
    return fromTimestamp(Timestamp.fromJSON(o));
  }
}

function isSet(value: any): boolean {
  return value !== null && value !== undefined;
}

export interface MessageFns<T> {
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
}