// @generated by protobuf-ts 2.9.6
// @generated from protobuf file "validate.proto" (package "validate", syntax proto2)
// tslint:disable
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import { WireType } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { Timestamp } from "./google/protobuf/timestamp";
import { Duration } from "./google/protobuf/duration";
/**
 * FieldRules encapsulates the rules for each type of field. Depending on the
 * field, the correct set should be used to ensure proper validations.
 *
 * @generated from protobuf message validate.FieldRules
 */
export interface FieldRules {
    /**
     * @generated from protobuf field: optional validate.MessageRules message = 17;
     */
    message?: MessageRules;
    /**
     * @generated from protobuf oneof: type
     */
    type: {
        oneofKind: "float";
        /**
         * Scalar Field Types
         *
         * @generated from protobuf field: validate.FloatRules float = 1;
         */
        float: FloatRules;
    } | {
        oneofKind: "double";
        /**
         * @generated from protobuf field: validate.DoubleRules double = 2;
         */
        double: DoubleRules;
    } | {
        oneofKind: "int32";
        /**
         * @generated from protobuf field: validate.Int32Rules int32 = 3;
         */
        int32: Int32Rules;
    } | {
        oneofKind: "int64";
        /**
         * @generated from protobuf field: validate.Int64Rules int64 = 4;
         */
        int64: Int64Rules;
    } | {
        oneofKind: "uint32";
        /**
         * @generated from protobuf field: validate.UInt32Rules uint32 = 5;
         */
        uint32: UInt32Rules;
    } | {
        oneofKind: "uint64";
        /**
         * @generated from protobuf field: validate.UInt64Rules uint64 = 6;
         */
        uint64: UInt64Rules;
    } | {
        oneofKind: "sint32";
        /**
         * @generated from protobuf field: validate.SInt32Rules sint32 = 7;
         */
        sint32: SInt32Rules;
    } | {
        oneofKind: "sint64";
        /**
         * @generated from protobuf field: validate.SInt64Rules sint64 = 8;
         */
        sint64: SInt64Rules;
    } | {
        oneofKind: "fixed32";
        /**
         * @generated from protobuf field: validate.Fixed32Rules fixed32 = 9;
         */
        fixed32: Fixed32Rules;
    } | {
        oneofKind: "fixed64";
        /**
         * @generated from protobuf field: validate.Fixed64Rules fixed64 = 10;
         */
        fixed64: Fixed64Rules;
    } | {
        oneofKind: "sfixed32";
        /**
         * @generated from protobuf field: validate.SFixed32Rules sfixed32 = 11;
         */
        sfixed32: SFixed32Rules;
    } | {
        oneofKind: "sfixed64";
        /**
         * @generated from protobuf field: validate.SFixed64Rules sfixed64 = 12;
         */
        sfixed64: SFixed64Rules;
    } | {
        oneofKind: "bool";
        /**
         * @generated from protobuf field: validate.BoolRules bool = 13;
         */
        bool: BoolRules;
    } | {
        oneofKind: "string";
        /**
         * @generated from protobuf field: validate.StringRules string = 14;
         */
        string: StringRules;
    } | {
        oneofKind: "bytes";
        /**
         * @generated from protobuf field: validate.BytesRules bytes = 15;
         */
        bytes: BytesRules;
    } | {
        oneofKind: "enum";
        /**
         * Complex Field Types
         *
         * @generated from protobuf field: validate.EnumRules enum = 16;
         */
        enum: EnumRules;
    } | {
        oneofKind: "repeated";
        /**
         * @generated from protobuf field: validate.RepeatedRules repeated = 18;
         */
        repeated: RepeatedRules;
    } | {
        oneofKind: "map";
        /**
         * @generated from protobuf field: validate.MapRules map = 19;
         */
        map: MapRules;
    } | {
        oneofKind: "any";
        /**
         * Well-Known Field Types
         *
         * @generated from protobuf field: validate.AnyRules any = 20;
         */
        any: AnyRules;
    } | {
        oneofKind: "duration";
        /**
         * @generated from protobuf field: validate.DurationRules duration = 21;
         */
        duration: DurationRules;
    } | {
        oneofKind: "timestamp";
        /**
         * @generated from protobuf field: validate.TimestampRules timestamp = 22;
         */
        timestamp: TimestampRules;
    } | {
        oneofKind: undefined;
    };
}
/**
 * FloatRules describes the constraints applied to `float` values
 *
 * @generated from protobuf message validate.FloatRules
 */
export interface FloatRules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional float const = 1;
     */
    const?: number;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional float lt = 2;
     */
    lt?: number;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional float lte = 3;
     */
    lte?: number;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional float gt = 4;
     */
    gt?: number;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional float gte = 5;
     */
    gte?: number;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated float in = 6;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated float not_in = 7;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * DoubleRules describes the constraints applied to `double` values
 *
 * @generated from protobuf message validate.DoubleRules
 */
export interface DoubleRules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional double const = 1;
     */
    const?: number;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional double lt = 2;
     */
    lt?: number;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional double lte = 3;
     */
    lte?: number;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional double gt = 4;
     */
    gt?: number;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional double gte = 5;
     */
    gte?: number;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated double in = 6;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated double not_in = 7;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * Int32Rules describes the constraints applied to `int32` values
 *
 * @generated from protobuf message validate.Int32Rules
 */
export interface Int32Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional int32 const = 1;
     */
    const?: number;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional int32 lt = 2;
     */
    lt?: number;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional int32 lte = 3;
     */
    lte?: number;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional int32 gt = 4;
     */
    gt?: number;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional int32 gte = 5;
     */
    gte?: number;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated int32 in = 6;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated int32 not_in = 7;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * Int64Rules describes the constraints applied to `int64` values
 *
 * @generated from protobuf message validate.Int64Rules
 */
export interface Int64Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional int64 const = 1;
     */
    const?: bigint;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional int64 lt = 2;
     */
    lt?: bigint;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional int64 lte = 3;
     */
    lte?: bigint;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional int64 gt = 4;
     */
    gt?: bigint;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional int64 gte = 5;
     */
    gte?: bigint;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated int64 in = 6;
     */
    in: bigint[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated int64 not_in = 7;
     */
    notIn: bigint[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * UInt32Rules describes the constraints applied to `uint32` values
 *
 * @generated from protobuf message validate.UInt32Rules
 */
export interface UInt32Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional uint32 const = 1;
     */
    const?: number;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional uint32 lt = 2;
     */
    lt?: number;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional uint32 lte = 3;
     */
    lte?: number;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional uint32 gt = 4;
     */
    gt?: number;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional uint32 gte = 5;
     */
    gte?: number;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated uint32 in = 6;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated uint32 not_in = 7;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * UInt64Rules describes the constraints applied to `uint64` values
 *
 * @generated from protobuf message validate.UInt64Rules
 */
export interface UInt64Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional uint64 const = 1;
     */
    const?: bigint;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional uint64 lt = 2;
     */
    lt?: bigint;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional uint64 lte = 3;
     */
    lte?: bigint;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional uint64 gt = 4;
     */
    gt?: bigint;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional uint64 gte = 5;
     */
    gte?: bigint;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated uint64 in = 6;
     */
    in: bigint[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated uint64 not_in = 7;
     */
    notIn: bigint[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * SInt32Rules describes the constraints applied to `sint32` values
 *
 * @generated from protobuf message validate.SInt32Rules
 */
export interface SInt32Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional sint32 const = 1;
     */
    const?: number;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional sint32 lt = 2;
     */
    lt?: number;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional sint32 lte = 3;
     */
    lte?: number;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional sint32 gt = 4;
     */
    gt?: number;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional sint32 gte = 5;
     */
    gte?: number;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sint32 in = 6;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sint32 not_in = 7;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * SInt64Rules describes the constraints applied to `sint64` values
 *
 * @generated from protobuf message validate.SInt64Rules
 */
export interface SInt64Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional sint64 const = 1;
     */
    const?: bigint;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional sint64 lt = 2;
     */
    lt?: bigint;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional sint64 lte = 3;
     */
    lte?: bigint;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional sint64 gt = 4;
     */
    gt?: bigint;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional sint64 gte = 5;
     */
    gte?: bigint;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sint64 in = 6;
     */
    in: bigint[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sint64 not_in = 7;
     */
    notIn: bigint[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * Fixed32Rules describes the constraints applied to `fixed32` values
 *
 * @generated from protobuf message validate.Fixed32Rules
 */
export interface Fixed32Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional fixed32 const = 1;
     */
    const?: number;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional fixed32 lt = 2;
     */
    lt?: number;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional fixed32 lte = 3;
     */
    lte?: number;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional fixed32 gt = 4;
     */
    gt?: number;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional fixed32 gte = 5;
     */
    gte?: number;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated fixed32 in = 6;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated fixed32 not_in = 7;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * Fixed64Rules describes the constraints applied to `fixed64` values
 *
 * @generated from protobuf message validate.Fixed64Rules
 */
export interface Fixed64Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional fixed64 const = 1;
     */
    const?: bigint;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional fixed64 lt = 2;
     */
    lt?: bigint;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional fixed64 lte = 3;
     */
    lte?: bigint;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional fixed64 gt = 4;
     */
    gt?: bigint;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional fixed64 gte = 5;
     */
    gte?: bigint;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated fixed64 in = 6;
     */
    in: bigint[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated fixed64 not_in = 7;
     */
    notIn: bigint[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * SFixed32Rules describes the constraints applied to `sfixed32` values
 *
 * @generated from protobuf message validate.SFixed32Rules
 */
export interface SFixed32Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional sfixed32 const = 1;
     */
    const?: number;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional sfixed32 lt = 2;
     */
    lt?: number;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional sfixed32 lte = 3;
     */
    lte?: number;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional sfixed32 gt = 4;
     */
    gt?: number;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional sfixed32 gte = 5;
     */
    gte?: number;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sfixed32 in = 6;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sfixed32 not_in = 7;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * SFixed64Rules describes the constraints applied to `sfixed64` values
 *
 * @generated from protobuf message validate.SFixed64Rules
 */
export interface SFixed64Rules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional sfixed64 const = 1;
     */
    const?: bigint;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional sfixed64 lt = 2;
     */
    lt?: bigint;
    /**
     * Lte specifies that this field must be less than or equal to the
     * specified value, inclusive
     *
     * @generated from protobuf field: optional sfixed64 lte = 3;
     */
    lte?: bigint;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive. If the value of Gt is larger than a specified Lt or Lte, the
     * range is reversed.
     *
     * @generated from protobuf field: optional sfixed64 gt = 4;
     */
    gt?: bigint;
    /**
     * Gte specifies that this field must be greater than or equal to the
     * specified value, inclusive. If the value of Gte is larger than a
     * specified Lt or Lte, the range is reversed.
     *
     * @generated from protobuf field: optional sfixed64 gte = 5;
     */
    gte?: bigint;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sfixed64 in = 6;
     */
    in: bigint[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated sfixed64 not_in = 7;
     */
    notIn: bigint[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 8;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 9;
     */
    ignoreEmpty?: boolean;
}
/**
 * BoolRules describes the constraints applied to `bool` values
 *
 * @generated from protobuf message validate.BoolRules
 */
export interface BoolRules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional bool const = 1;
     */
    const?: boolean;
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 2;
     */
    unauthorized?: boolean;
}
/**
 * StringRules describe the constraints applied to `string` values
 *
 * @generated from protobuf message validate.StringRules
 */
export interface StringRules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional string const = 1;
     */
    const?: string;
    /**
     * Len specifies that this field must be the specified number of
     * characters (Unicode code points). Note that the number of
     * characters may differ from the number of bytes in the string.
     *
     * @generated from protobuf field: optional uint64 len = 19;
     */
    len?: bigint;
    /**
     * MinLen specifies that this field must be the specified number of
     * characters (Unicode code points) at a minimum. Note that the number of
     * characters may differ from the number of bytes in the string.
     *
     * @generated from protobuf field: optional uint64 min_len = 2;
     */
    minLen?: bigint;
    /**
     * MaxLen specifies that this field must be the specified number of
     * characters (Unicode code points) at a maximum. Note that the number of
     * characters may differ from the number of bytes in the string.
     *
     * @generated from protobuf field: optional uint64 max_len = 3;
     */
    maxLen?: bigint;
    /**
     * LenBytes specifies that this field must be the specified number of bytes
     * at a minimum
     *
     * @generated from protobuf field: optional uint64 len_bytes = 20;
     */
    lenBytes?: bigint;
    /**
     * MinBytes specifies that this field must be the specified number of bytes
     * at a minimum
     *
     * @generated from protobuf field: optional uint64 min_bytes = 4;
     */
    minBytes?: bigint;
    /**
     * MaxBytes specifies that this field must be the specified number of bytes
     * at a maximum
     *
     * @generated from protobuf field: optional uint64 max_bytes = 5;
     */
    maxBytes?: bigint;
    /**
     * Pattern specifes that this field must match against the specified
     * regular expression (RE2 syntax). The included expression should elide
     * any delimiters.
     *
     * @generated from protobuf field: optional string pattern = 6;
     */
    pattern?: string;
    /**
     * Prefix specifies that this field must have the specified substring at
     * the beginning of the string.
     *
     * @generated from protobuf field: optional string prefix = 7;
     */
    prefix?: string;
    /**
     * Suffix specifies that this field must have the specified substring at
     * the end of the string.
     *
     * @generated from protobuf field: optional string suffix = 8;
     */
    suffix?: string;
    /**
     * Contains specifies that this field must have the specified substring
     * anywhere in the string.
     *
     * @generated from protobuf field: optional string contains = 9;
     */
    contains?: string;
    /**
     * NotContains specifies that this field cannot have the specified substring
     * anywhere in the string.
     *
     * @generated from protobuf field: optional string not_contains = 23;
     */
    notContains?: string;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated string in = 10;
     */
    in: string[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated string not_in = 11;
     */
    notIn: string[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 29;
     */
    unauthorized?: boolean;
    /**
     * @generated from protobuf oneof: well_known
     */
    wellKnown: {
        oneofKind: "email";
        /**
         * Email specifies that the field must be a valid email address as
         * defined by RFC 5322
         *
         * @generated from protobuf field: bool email = 12;
         */
        email: boolean;
    } | {
        oneofKind: "hostname";
        /**
         * Hostname specifies that the field must be a valid hostname as
         * defined by RFC 1034. This constraint does not support
         * internationalized domain names (IDNs).
         *
         * @generated from protobuf field: bool hostname = 13;
         */
        hostname: boolean;
    } | {
        oneofKind: "ip";
        /**
         * Ip specifies that the field must be a valid IP (v4 or v6) address.
         * Valid IPv6 addresses should not include surrounding square brackets.
         *
         * @generated from protobuf field: bool ip = 14;
         */
        ip: boolean;
    } | {
        oneofKind: "ipv4";
        /**
         * Ipv4 specifies that the field must be a valid IPv4 address.
         *
         * @generated from protobuf field: bool ipv4 = 15;
         */
        ipv4: boolean;
    } | {
        oneofKind: "ipv6";
        /**
         * Ipv6 specifies that the field must be a valid IPv6 address. Valid
         * IPv6 addresses should not include surrounding square brackets.
         *
         * @generated from protobuf field: bool ipv6 = 16;
         */
        ipv6: boolean;
    } | {
        oneofKind: "uri";
        /**
         * Uri specifies that the field must be a valid, absolute URI as defined
         * by RFC 3986
         *
         * @generated from protobuf field: bool uri = 17;
         */
        uri: boolean;
    } | {
        oneofKind: "uriRef";
        /**
         * UriRef specifies that the field must be a valid URI as defined by RFC
         * 3986 and may be relative or absolute.
         *
         * @generated from protobuf field: bool uri_ref = 18;
         */
        uriRef: boolean;
    } | {
        oneofKind: "address";
        /**
         * Address specifies that the field must be either a valid hostname as
         * defined by RFC 1034 (which does not support internationalized domain
         * names or IDNs), or it can be a valid IP (v4 or v6).
         *
         * @generated from protobuf field: bool address = 21;
         */
        address: boolean;
    } | {
        oneofKind: "uuid";
        /**
         * Uuid specifies that the field must be a valid UUID as defined by
         * RFC 4122
         *
         * @generated from protobuf field: bool uuid = 22;
         */
        uuid: boolean;
    } | {
        oneofKind: "wellKnownRegex";
        /**
         * WellKnownRegex specifies a common well known pattern defined as a regex.
         *
         * @generated from protobuf field: validate.KnownRegex well_known_regex = 24;
         */
        wellKnownRegex: KnownRegex;
    } | {
        oneofKind: "dateIso8601";
        /**
         * dateIso8601 specifes that the field must be either a valid date as
         * defined by ISO 8601
         *
         * @generated from protobuf field: bool dateIso8601 = 26;
         */
        dateIso8601: boolean;
    } | {
        oneofKind: "languageIso6391";
        /**
         * languageIso639 specifes that the field must be either a valid language name as
         * defined by ISO 639-1
         *
         * @generated from protobuf field: bool languageIso6391 = 27;
         */
        languageIso6391: boolean;
    } | {
        oneofKind: "tzData";
        /**
         * tzData specifes that the field must be  location name
         * corresponding to a file in the IANA Time Zone database, such as "America/New_York"
         *
         * @generated from protobuf field: bool tzData = 28;
         */
        tzData: boolean;
    } | {
        oneofKind: "countryCodeIso3166";
        /**
         * countryCodeIso3166 specifes that the field must be either a valid country code as
         * defined by ISO 3166
         *
         * @generated from protobuf field: bool countryCodeIso3166 = 31;
         */
        countryCodeIso3166: boolean;
    } | {
        oneofKind: "languageIso639";
        /**
         * languageIso639 specifes that the field must be either a valid language name as
         * defined by ISO 639-1, 639-2, or 639-3
         *
         * @generated from protobuf field: bool languageIso639 = 32;
         */
        languageIso639: boolean;
    } | {
        oneofKind: undefined;
    };
    /**
     * This applies to regexes HTTP_HEADER_NAME and HTTP_HEADER_VALUE to enable
     * strict header validation.
     * By default, this is true, and HTTP header validations are RFC-compliant.
     * Setting to false will enable a looser validations that only disallows
     * \r\n\0 characters, which can be used to bypass header matching rules.
     *
     * @generated from protobuf field: optional bool strict = 25;
     */
    strict?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 30;
     */
    ignoreEmpty?: boolean;
}
/**
 * BytesRules describe the constraints applied to `bytes` values
 *
 * @generated from protobuf message validate.BytesRules
 */
export interface BytesRules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional bytes const = 1;
     */
    const?: Uint8Array;
    /**
     * Len specifies that this field must be the specified number of bytes
     *
     * @generated from protobuf field: optional uint64 len = 13;
     */
    len?: bigint;
    /**
     * MinLen specifies that this field must be the specified number of bytes
     * at a minimum
     *
     * @generated from protobuf field: optional uint64 min_len = 2;
     */
    minLen?: bigint;
    /**
     * MaxLen specifies that this field must be the specified number of bytes
     * at a maximum
     *
     * @generated from protobuf field: optional uint64 max_len = 3;
     */
    maxLen?: bigint;
    /**
     * Pattern specifes that this field must match against the specified
     * regular expression (RE2 syntax). The included expression should elide
     * any delimiters.
     *
     * @generated from protobuf field: optional string pattern = 4;
     */
    pattern?: string;
    /**
     * Prefix specifies that this field must have the specified bytes at the
     * beginning of the string.
     *
     * @generated from protobuf field: optional bytes prefix = 5;
     */
    prefix?: Uint8Array;
    /**
     * Suffix specifies that this field must have the specified bytes at the
     * end of the string.
     *
     * @generated from protobuf field: optional bytes suffix = 6;
     */
    suffix?: Uint8Array;
    /**
     * Contains specifies that this field must have the specified bytes
     * anywhere in the string.
     *
     * @generated from protobuf field: optional bytes contains = 7;
     */
    contains?: Uint8Array;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated bytes in = 8;
     */
    in: Uint8Array[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated bytes not_in = 9;
     */
    notIn: Uint8Array[];
    /**
     * @generated from protobuf oneof: well_known
     */
    wellKnown: {
        oneofKind: "ip";
        /**
         * Ip specifies that the field must be a valid IP (v4 or v6) address in
         * byte format
         *
         * @generated from protobuf field: bool ip = 10;
         */
        ip: boolean;
    } | {
        oneofKind: "ipv4";
        /**
         * Ipv4 specifies that the field must be a valid IPv4 address in byte
         * format
         *
         * @generated from protobuf field: bool ipv4 = 11;
         */
        ipv4: boolean;
    } | {
        oneofKind: "ipv6";
        /**
         * Ipv6 specifies that the field must be a valid IPv6 address in byte
         * format
         *
         * @generated from protobuf field: bool ipv6 = 12;
         */
        ipv6: boolean;
    } | {
        oneofKind: undefined;
    };
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 14;
     */
    ignoreEmpty?: boolean;
}
/**
 * EnumRules describe the constraints applied to enum values
 *
 * @generated from protobuf message validate.EnumRules
 */
export interface EnumRules {
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional int32 const = 1;
     */
    const?: number;
    /**
     * DefinedOnly specifies that this field must be only one of the defined
     * values for this enum, failing on any undefined value.
     *
     * @generated from protobuf field: optional bool defined_only = 2;
     */
    definedOnly?: boolean;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated int32 in = 3;
     */
    in: number[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated int32 not_in = 4;
     */
    notIn: number[];
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 5;
     */
    unauthorized?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 6;
     */
    ignoreEmpty?: boolean;
}
/**
 * MessageRules describe the constraints applied to embedded message values.
 * For message-type fields, validation is performed recursively.
 *
 * @generated from protobuf message validate.MessageRules
 */
export interface MessageRules {
    /**
     * Skip specifies that the validation rules of this field should not be
     * evaluated
     *
     * @generated from protobuf field: optional bool skip = 1;
     */
    skip?: boolean;
    /**
     * Required specifies that this field must be set
     *
     * @generated from protobuf field: optional bool required = 2;
     */
    required?: boolean;
    /**
     * unauthorized specifies that this field cannot be written.
     *
     * @generated from protobuf field: optional bool unauthorized = 3;
     */
    unauthorized?: boolean;
}
/**
 * RepeatedRules describe the constraints applied to `repeated` values
 *
 * @generated from protobuf message validate.RepeatedRules
 */
export interface RepeatedRules {
    /**
     * MinItems specifies that this field must have the specified number of
     * items at a minimum
     *
     * @generated from protobuf field: optional uint64 min_items = 1;
     */
    minItems?: bigint;
    /**
     * MaxItems specifies that this field must have the specified number of
     * items at a maximum
     *
     * @generated from protobuf field: optional uint64 max_items = 2;
     */
    maxItems?: bigint;
    /**
     * Unique specifies that all elements in this field must be unique. This
     * contraint is only applicable to scalar and enum types (messages are not
     * supported).
     *
     * @generated from protobuf field: optional bool unique = 3;
     */
    unique?: boolean;
    /**
     * Items specifies the contraints to be applied to each item in the field.
     * Repeated message fields will still execute validation against each item
     * unless skip is specified here.
     *
     * @generated from protobuf field: optional validate.FieldRules items = 4;
     */
    items?: FieldRules;
    /**
     * uniqueBaseLV specifies the business rule contraints to the IsBaseLogisticVariant nested field of the LogisticVariant item in the list.
     * An item can only have one base LV.
     * Contraint is only applicable to the LogisticVariant field.
     *
     * @generated from protobuf field: optional bool uniqueBaseLV = 5;
     */
    uniqueBaseLV?: boolean;
    /**
     * knownRefLV specifies the business rule contraints to the IsBaseLogisticVariant nested field of the LogisticVariant item in the list.
     * A VL can only refer (RefLV) to a base LV known on this article.
     * Contraint is only applicable to the LogisticVariant field.
     *
     * @generated from protobuf field: optional bool knownRefLV = 6;
     */
    knownRefLV?: boolean;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 7;
     */
    ignoreEmpty?: boolean;
}
/**
 * MapRules describe the constraints applied to `map` values
 *
 * @generated from protobuf message validate.MapRules
 */
export interface MapRules {
    /**
     * MinPairs specifies that this field must have the specified number of
     * KVs at a minimum
     *
     * @generated from protobuf field: optional uint64 min_pairs = 1;
     */
    minPairs?: bigint;
    /**
     * MaxPairs specifies that this field must have the specified number of
     * KVs at a maximum
     *
     * @generated from protobuf field: optional uint64 max_pairs = 2;
     */
    maxPairs?: bigint;
    /**
     * NoSparse specifies values in this field cannot be unset. This only
     * applies to map's with message value types.
     *
     * @generated from protobuf field: optional bool no_sparse = 3;
     */
    noSparse?: boolean;
    /**
     * Keys specifies the constraints to be applied to each key in the field.
     *
     * @generated from protobuf field: optional validate.FieldRules keys = 4;
     */
    keys?: FieldRules;
    /**
     * Values specifies the constraints to be applied to the value of each key
     * in the field. Message values will still have their validations evaluated
     * unless skip is specified here.
     *
     * @generated from protobuf field: optional validate.FieldRules values = 5;
     */
    values?: FieldRules;
    /**
     * IgnoreEmpty specifies that the validation rules of this field should be
     * evaluated only if the field is not empty
     *
     * @generated from protobuf field: optional bool ignore_empty = 6;
     */
    ignoreEmpty?: boolean;
}
/**
 * AnyRules describe constraints applied exclusively to the
 * `google.protobuf.Any` well-known type
 *
 * @generated from protobuf message validate.AnyRules
 */
export interface AnyRules {
    /**
     * Required specifies that this field must be set
     *
     * @generated from protobuf field: optional bool required = 1;
     */
    required?: boolean;
    /**
     * In specifies that this field's `type_url` must be equal to one of the
     * specified values.
     *
     * @generated from protobuf field: repeated string in = 2;
     */
    in: string[];
    /**
     * NotIn specifies that this field's `type_url` must not be equal to any of
     * the specified values.
     *
     * @generated from protobuf field: repeated string not_in = 3;
     */
    notIn: string[];
}
/**
 * DurationRules describe the constraints applied exclusively to the
 * `google.protobuf.Duration` well-known type
 *
 * @generated from protobuf message validate.DurationRules
 */
export interface DurationRules {
    /**
     * Required specifies that this field must be set
     *
     * @generated from protobuf field: optional bool required = 1;
     */
    required?: boolean;
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional google.protobuf.Duration const = 2;
     */
    const?: Duration;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional google.protobuf.Duration lt = 3;
     */
    lt?: Duration;
    /**
     * Lt specifies that this field must be less than the specified value,
     * inclusive
     *
     * @generated from protobuf field: optional google.protobuf.Duration lte = 4;
     */
    lte?: Duration;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional google.protobuf.Duration gt = 5;
     */
    gt?: Duration;
    /**
     * Gte specifies that this field must be greater than the specified value,
     * inclusive
     *
     * @generated from protobuf field: optional google.protobuf.Duration gte = 6;
     */
    gte?: Duration;
    /**
     * In specifies that this field must be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated google.protobuf.Duration in = 7;
     */
    in: Duration[];
    /**
     * NotIn specifies that this field cannot be equal to one of the specified
     * values
     *
     * @generated from protobuf field: repeated google.protobuf.Duration not_in = 8;
     */
    notIn: Duration[];
}
/**
 * TimestampRules describe the constraints applied exclusively to the
 * `google.protobuf.Timestamp` well-known type
 *
 * @generated from protobuf message validate.TimestampRules
 */
export interface TimestampRules {
    /**
     * Required specifies that this field must be set
     *
     * @generated from protobuf field: optional bool required = 1;
     */
    required?: boolean;
    /**
     * Const specifies that this field must be exactly the specified value
     *
     * @generated from protobuf field: optional google.protobuf.Timestamp const = 2;
     */
    const?: Timestamp;
    /**
     * Lt specifies that this field must be less than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional google.protobuf.Timestamp lt = 3;
     */
    lt?: Timestamp;
    /**
     * Lte specifies that this field must be less than the specified value,
     * inclusive
     *
     * @generated from protobuf field: optional google.protobuf.Timestamp lte = 4;
     */
    lte?: Timestamp;
    /**
     * Gt specifies that this field must be greater than the specified value,
     * exclusive
     *
     * @generated from protobuf field: optional google.protobuf.Timestamp gt = 5;
     */
    gt?: Timestamp;
    /**
     * Gte specifies that this field must be greater than the specified value,
     * inclusive
     *
     * @generated from protobuf field: optional google.protobuf.Timestamp gte = 6;
     */
    gte?: Timestamp;
    /**
     * LtNow specifies that this must be less than the current time. LtNow
     * can only be used with the Within rule.
     *
     * @generated from protobuf field: optional bool lt_now = 7;
     */
    ltNow?: boolean;
    /**
     * GtNow specifies that this must be greater than the current time. GtNow
     * can only be used with the Within rule.
     *
     * @generated from protobuf field: optional bool gt_now = 8;
     */
    gtNow?: boolean;
    /**
     * Within specifies that this field must be within this duration of the
     * current time. This constraint can be used alone or with the LtNow and
     * GtNow rules.
     *
     * @generated from protobuf field: optional google.protobuf.Duration within = 9;
     */
    within?: Duration;
}
/**
 * WellKnownRegex contain some well-known patterns.
 *
 * @generated from protobuf enum validate.KnownRegex
 */
export enum KnownRegex {
    /**
     * @generated from protobuf enum value: UNKNOWN = 0;
     */
    UNKNOWN = 0,
    /**
     * HTTP header name as defined by RFC 7230.
     *
     * @generated from protobuf enum value: HTTP_HEADER_NAME = 1;
     */
    HTTP_HEADER_NAME = 1,
    /**
     * HTTP header value as defined by RFC 7230.
     *
     * @generated from protobuf enum value: HTTP_HEADER_VALUE = 2;
     */
    HTTP_HEADER_VALUE = 2
}
// @generated message type with reflection information, may provide speed optimized methods
class FieldRules$Type extends MessageType<FieldRules> {
    constructor() {
        super("validate.FieldRules", [
            { no: 17, name: "message", kind: "message", T: () => MessageRules },
            { no: 1, name: "float", kind: "message", oneof: "type", T: () => FloatRules },
            { no: 2, name: "double", kind: "message", oneof: "type", T: () => DoubleRules },
            { no: 3, name: "int32", kind: "message", oneof: "type", T: () => Int32Rules },
            { no: 4, name: "int64", kind: "message", oneof: "type", T: () => Int64Rules },
            { no: 5, name: "uint32", kind: "message", oneof: "type", T: () => UInt32Rules },
            { no: 6, name: "uint64", kind: "message", oneof: "type", T: () => UInt64Rules },
            { no: 7, name: "sint32", kind: "message", oneof: "type", T: () => SInt32Rules },
            { no: 8, name: "sint64", kind: "message", oneof: "type", T: () => SInt64Rules },
            { no: 9, name: "fixed32", kind: "message", oneof: "type", T: () => Fixed32Rules },
            { no: 10, name: "fixed64", kind: "message", oneof: "type", T: () => Fixed64Rules },
            { no: 11, name: "sfixed32", kind: "message", oneof: "type", T: () => SFixed32Rules },
            { no: 12, name: "sfixed64", kind: "message", oneof: "type", T: () => SFixed64Rules },
            { no: 13, name: "bool", kind: "message", oneof: "type", T: () => BoolRules },
            { no: 14, name: "string", kind: "message", oneof: "type", T: () => StringRules },
            { no: 15, name: "bytes", kind: "message", oneof: "type", T: () => BytesRules },
            { no: 16, name: "enum", kind: "message", oneof: "type", T: () => EnumRules },
            { no: 18, name: "repeated", kind: "message", oneof: "type", T: () => RepeatedRules },
            { no: 19, name: "map", kind: "message", oneof: "type", T: () => MapRules },
            { no: 20, name: "any", kind: "message", oneof: "type", T: () => AnyRules },
            { no: 21, name: "duration", kind: "message", oneof: "type", T: () => DurationRules },
            { no: 22, name: "timestamp", kind: "message", oneof: "type", T: () => TimestampRules }
        ]);
    }
    create(value?: PartialMessage<FieldRules>): FieldRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.type = { oneofKind: undefined };
        if (value !== undefined)
            reflectionMergePartial<FieldRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FieldRules): FieldRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional validate.MessageRules message */ 17:
                    message.message = MessageRules.internalBinaryRead(reader, reader.uint32(), options, message.message);
                    break;
                case /* validate.FloatRules float */ 1:
                    message.type = {
                        oneofKind: "float",
                        float: FloatRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).float)
                    };
                    break;
                case /* validate.DoubleRules double */ 2:
                    message.type = {
                        oneofKind: "double",
                        double: DoubleRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).double)
                    };
                    break;
                case /* validate.Int32Rules int32 */ 3:
                    message.type = {
                        oneofKind: "int32",
                        int32: Int32Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).int32)
                    };
                    break;
                case /* validate.Int64Rules int64 */ 4:
                    message.type = {
                        oneofKind: "int64",
                        int64: Int64Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).int64)
                    };
                    break;
                case /* validate.UInt32Rules uint32 */ 5:
                    message.type = {
                        oneofKind: "uint32",
                        uint32: UInt32Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).uint32)
                    };
                    break;
                case /* validate.UInt64Rules uint64 */ 6:
                    message.type = {
                        oneofKind: "uint64",
                        uint64: UInt64Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).uint64)
                    };
                    break;
                case /* validate.SInt32Rules sint32 */ 7:
                    message.type = {
                        oneofKind: "sint32",
                        sint32: SInt32Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).sint32)
                    };
                    break;
                case /* validate.SInt64Rules sint64 */ 8:
                    message.type = {
                        oneofKind: "sint64",
                        sint64: SInt64Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).sint64)
                    };
                    break;
                case /* validate.Fixed32Rules fixed32 */ 9:
                    message.type = {
                        oneofKind: "fixed32",
                        fixed32: Fixed32Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).fixed32)
                    };
                    break;
                case /* validate.Fixed64Rules fixed64 */ 10:
                    message.type = {
                        oneofKind: "fixed64",
                        fixed64: Fixed64Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).fixed64)
                    };
                    break;
                case /* validate.SFixed32Rules sfixed32 */ 11:
                    message.type = {
                        oneofKind: "sfixed32",
                        sfixed32: SFixed32Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).sfixed32)
                    };
                    break;
                case /* validate.SFixed64Rules sfixed64 */ 12:
                    message.type = {
                        oneofKind: "sfixed64",
                        sfixed64: SFixed64Rules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).sfixed64)
                    };
                    break;
                case /* validate.BoolRules bool */ 13:
                    message.type = {
                        oneofKind: "bool",
                        bool: BoolRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).bool)
                    };
                    break;
                case /* validate.StringRules string */ 14:
                    message.type = {
                        oneofKind: "string",
                        string: StringRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).string)
                    };
                    break;
                case /* validate.BytesRules bytes */ 15:
                    message.type = {
                        oneofKind: "bytes",
                        bytes: BytesRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).bytes)
                    };
                    break;
                case /* validate.EnumRules enum */ 16:
                    message.type = {
                        oneofKind: "enum",
                        enum: EnumRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).enum)
                    };
                    break;
                case /* validate.RepeatedRules repeated */ 18:
                    message.type = {
                        oneofKind: "repeated",
                        repeated: RepeatedRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).repeated)
                    };
                    break;
                case /* validate.MapRules map */ 19:
                    message.type = {
                        oneofKind: "map",
                        map: MapRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).map)
                    };
                    break;
                case /* validate.AnyRules any */ 20:
                    message.type = {
                        oneofKind: "any",
                        any: AnyRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).any)
                    };
                    break;
                case /* validate.DurationRules duration */ 21:
                    message.type = {
                        oneofKind: "duration",
                        duration: DurationRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).duration)
                    };
                    break;
                case /* validate.TimestampRules timestamp */ 22:
                    message.type = {
                        oneofKind: "timestamp",
                        timestamp: TimestampRules.internalBinaryRead(reader, reader.uint32(), options, (message.type as any).timestamp)
                    };
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: FieldRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional validate.MessageRules message = 17; */
        if (message.message)
            MessageRules.internalBinaryWrite(message.message, writer.tag(17, WireType.LengthDelimited).fork(), options).join();
        /* validate.FloatRules float = 1; */
        if (message.type.oneofKind === "float")
            FloatRules.internalBinaryWrite(message.type.float, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* validate.DoubleRules double = 2; */
        if (message.type.oneofKind === "double")
            DoubleRules.internalBinaryWrite(message.type.double, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* validate.Int32Rules int32 = 3; */
        if (message.type.oneofKind === "int32")
            Int32Rules.internalBinaryWrite(message.type.int32, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* validate.Int64Rules int64 = 4; */
        if (message.type.oneofKind === "int64")
            Int64Rules.internalBinaryWrite(message.type.int64, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        /* validate.UInt32Rules uint32 = 5; */
        if (message.type.oneofKind === "uint32")
            UInt32Rules.internalBinaryWrite(message.type.uint32, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
        /* validate.UInt64Rules uint64 = 6; */
        if (message.type.oneofKind === "uint64")
            UInt64Rules.internalBinaryWrite(message.type.uint64, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
        /* validate.SInt32Rules sint32 = 7; */
        if (message.type.oneofKind === "sint32")
            SInt32Rules.internalBinaryWrite(message.type.sint32, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
        /* validate.SInt64Rules sint64 = 8; */
        if (message.type.oneofKind === "sint64")
            SInt64Rules.internalBinaryWrite(message.type.sint64, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
        /* validate.Fixed32Rules fixed32 = 9; */
        if (message.type.oneofKind === "fixed32")
            Fixed32Rules.internalBinaryWrite(message.type.fixed32, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
        /* validate.Fixed64Rules fixed64 = 10; */
        if (message.type.oneofKind === "fixed64")
            Fixed64Rules.internalBinaryWrite(message.type.fixed64, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
        /* validate.SFixed32Rules sfixed32 = 11; */
        if (message.type.oneofKind === "sfixed32")
            SFixed32Rules.internalBinaryWrite(message.type.sfixed32, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
        /* validate.SFixed64Rules sfixed64 = 12; */
        if (message.type.oneofKind === "sfixed64")
            SFixed64Rules.internalBinaryWrite(message.type.sfixed64, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
        /* validate.BoolRules bool = 13; */
        if (message.type.oneofKind === "bool")
            BoolRules.internalBinaryWrite(message.type.bool, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
        /* validate.StringRules string = 14; */
        if (message.type.oneofKind === "string")
            StringRules.internalBinaryWrite(message.type.string, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
        /* validate.BytesRules bytes = 15; */
        if (message.type.oneofKind === "bytes")
            BytesRules.internalBinaryWrite(message.type.bytes, writer.tag(15, WireType.LengthDelimited).fork(), options).join();
        /* validate.EnumRules enum = 16; */
        if (message.type.oneofKind === "enum")
            EnumRules.internalBinaryWrite(message.type.enum, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
        /* validate.RepeatedRules repeated = 18; */
        if (message.type.oneofKind === "repeated")
            RepeatedRules.internalBinaryWrite(message.type.repeated, writer.tag(18, WireType.LengthDelimited).fork(), options).join();
        /* validate.MapRules map = 19; */
        if (message.type.oneofKind === "map")
            MapRules.internalBinaryWrite(message.type.map, writer.tag(19, WireType.LengthDelimited).fork(), options).join();
        /* validate.AnyRules any = 20; */
        if (message.type.oneofKind === "any")
            AnyRules.internalBinaryWrite(message.type.any, writer.tag(20, WireType.LengthDelimited).fork(), options).join();
        /* validate.DurationRules duration = 21; */
        if (message.type.oneofKind === "duration")
            DurationRules.internalBinaryWrite(message.type.duration, writer.tag(21, WireType.LengthDelimited).fork(), options).join();
        /* validate.TimestampRules timestamp = 22; */
        if (message.type.oneofKind === "timestamp")
            TimestampRules.internalBinaryWrite(message.type.timestamp, writer.tag(22, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.FieldRules
 */
export const FieldRules = new FieldRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class FloatRules$Type extends MessageType<FloatRules> {
    constructor() {
        super("validate.FloatRules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 2 /*ScalarType.FLOAT*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 2 /*ScalarType.FLOAT*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 2 /*ScalarType.FLOAT*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<FloatRules>): FloatRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<FloatRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: FloatRules): FloatRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional float const */ 1:
                    message.const = reader.float();
                    break;
                case /* optional float lt */ 2:
                    message.lt = reader.float();
                    break;
                case /* optional float lte */ 3:
                    message.lte = reader.float();
                    break;
                case /* optional float gt */ 4:
                    message.gt = reader.float();
                    break;
                case /* optional float gte */ 5:
                    message.gte = reader.float();
                    break;
                case /* repeated float in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.float());
                    else
                        message.in.push(reader.float());
                    break;
                case /* repeated float not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.float());
                    else
                        message.notIn.push(reader.float());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: FloatRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional float const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Bit32).float(message.const);
        /* optional float lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Bit32).float(message.lt);
        /* optional float lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Bit32).float(message.lte);
        /* optional float gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Bit32).float(message.gt);
        /* optional float gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Bit32).float(message.gte);
        /* repeated float in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Bit32).float(message.in[i]);
        /* repeated float not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Bit32).float(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.FloatRules
 */
export const FloatRules = new FloatRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DoubleRules$Type extends MessageType<DoubleRules> {
    constructor() {
        super("validate.DoubleRules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 1 /*ScalarType.DOUBLE*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 1 /*ScalarType.DOUBLE*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 1 /*ScalarType.DOUBLE*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<DoubleRules>): DoubleRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<DoubleRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DoubleRules): DoubleRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional double const */ 1:
                    message.const = reader.double();
                    break;
                case /* optional double lt */ 2:
                    message.lt = reader.double();
                    break;
                case /* optional double lte */ 3:
                    message.lte = reader.double();
                    break;
                case /* optional double gt */ 4:
                    message.gt = reader.double();
                    break;
                case /* optional double gte */ 5:
                    message.gte = reader.double();
                    break;
                case /* repeated double in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.double());
                    else
                        message.in.push(reader.double());
                    break;
                case /* repeated double not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.double());
                    else
                        message.notIn.push(reader.double());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: DoubleRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional double const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Bit64).double(message.const);
        /* optional double lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Bit64).double(message.lt);
        /* optional double lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Bit64).double(message.lte);
        /* optional double gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Bit64).double(message.gt);
        /* optional double gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Bit64).double(message.gte);
        /* repeated double in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Bit64).double(message.in[i]);
        /* repeated double not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Bit64).double(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.DoubleRules
 */
export const DoubleRules = new DoubleRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Int32Rules$Type extends MessageType<Int32Rules> {
    constructor() {
        super("validate.Int32Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<Int32Rules>): Int32Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<Int32Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int32Rules): Int32Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional int32 const */ 1:
                    message.const = reader.int32();
                    break;
                case /* optional int32 lt */ 2:
                    message.lt = reader.int32();
                    break;
                case /* optional int32 lte */ 3:
                    message.lte = reader.int32();
                    break;
                case /* optional int32 gt */ 4:
                    message.gt = reader.int32();
                    break;
                case /* optional int32 gte */ 5:
                    message.gte = reader.int32();
                    break;
                case /* repeated int32 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.int32());
                    else
                        message.in.push(reader.int32());
                    break;
                case /* repeated int32 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.int32());
                    else
                        message.notIn.push(reader.int32());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: Int32Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional int32 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).int32(message.const);
        /* optional int32 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Varint).int32(message.lt);
        /* optional int32 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Varint).int32(message.lte);
        /* optional int32 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Varint).int32(message.gt);
        /* optional int32 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Varint).int32(message.gte);
        /* repeated int32 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Varint).int32(message.in[i]);
        /* repeated int32 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Varint).int32(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.Int32Rules
 */
export const Int32Rules = new Int32Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Int64Rules$Type extends MessageType<Int64Rules> {
    constructor() {
        super("validate.Int64Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<Int64Rules>): Int64Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<Int64Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Int64Rules): Int64Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional int64 const */ 1:
                    message.const = reader.int64().toBigInt();
                    break;
                case /* optional int64 lt */ 2:
                    message.lt = reader.int64().toBigInt();
                    break;
                case /* optional int64 lte */ 3:
                    message.lte = reader.int64().toBigInt();
                    break;
                case /* optional int64 gt */ 4:
                    message.gt = reader.int64().toBigInt();
                    break;
                case /* optional int64 gte */ 5:
                    message.gte = reader.int64().toBigInt();
                    break;
                case /* repeated int64 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.int64().toBigInt());
                    else
                        message.in.push(reader.int64().toBigInt());
                    break;
                case /* repeated int64 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.int64().toBigInt());
                    else
                        message.notIn.push(reader.int64().toBigInt());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: Int64Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional int64 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).int64(message.const);
        /* optional int64 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Varint).int64(message.lt);
        /* optional int64 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Varint).int64(message.lte);
        /* optional int64 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Varint).int64(message.gt);
        /* optional int64 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Varint).int64(message.gte);
        /* repeated int64 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Varint).int64(message.in[i]);
        /* repeated int64 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Varint).int64(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.Int64Rules
 */
export const Int64Rules = new Int64Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UInt32Rules$Type extends MessageType<UInt32Rules> {
    constructor() {
        super("validate.UInt32Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 13 /*ScalarType.UINT32*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 13 /*ScalarType.UINT32*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<UInt32Rules>): UInt32Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<UInt32Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UInt32Rules): UInt32Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional uint32 const */ 1:
                    message.const = reader.uint32();
                    break;
                case /* optional uint32 lt */ 2:
                    message.lt = reader.uint32();
                    break;
                case /* optional uint32 lte */ 3:
                    message.lte = reader.uint32();
                    break;
                case /* optional uint32 gt */ 4:
                    message.gt = reader.uint32();
                    break;
                case /* optional uint32 gte */ 5:
                    message.gte = reader.uint32();
                    break;
                case /* repeated uint32 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.uint32());
                    else
                        message.in.push(reader.uint32());
                    break;
                case /* repeated uint32 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.uint32());
                    else
                        message.notIn.push(reader.uint32());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: UInt32Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional uint32 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).uint32(message.const);
        /* optional uint32 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Varint).uint32(message.lt);
        /* optional uint32 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Varint).uint32(message.lte);
        /* optional uint32 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Varint).uint32(message.gt);
        /* optional uint32 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Varint).uint32(message.gte);
        /* repeated uint32 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Varint).uint32(message.in[i]);
        /* repeated uint32 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Varint).uint32(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.UInt32Rules
 */
export const UInt32Rules = new UInt32Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class UInt64Rules$Type extends MessageType<UInt64Rules> {
    constructor() {
        super("validate.UInt64Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<UInt64Rules>): UInt64Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<UInt64Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: UInt64Rules): UInt64Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional uint64 const */ 1:
                    message.const = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 lt */ 2:
                    message.lt = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 lte */ 3:
                    message.lte = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 gt */ 4:
                    message.gt = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 gte */ 5:
                    message.gte = reader.uint64().toBigInt();
                    break;
                case /* repeated uint64 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.uint64().toBigInt());
                    else
                        message.in.push(reader.uint64().toBigInt());
                    break;
                case /* repeated uint64 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.uint64().toBigInt());
                    else
                        message.notIn.push(reader.uint64().toBigInt());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: UInt64Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional uint64 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).uint64(message.const);
        /* optional uint64 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Varint).uint64(message.lt);
        /* optional uint64 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Varint).uint64(message.lte);
        /* optional uint64 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Varint).uint64(message.gt);
        /* optional uint64 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Varint).uint64(message.gte);
        /* repeated uint64 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Varint).uint64(message.in[i]);
        /* repeated uint64 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Varint).uint64(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.UInt64Rules
 */
export const UInt64Rules = new UInt64Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SInt32Rules$Type extends MessageType<SInt32Rules> {
    constructor() {
        super("validate.SInt32Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 17 /*ScalarType.SINT32*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 17 /*ScalarType.SINT32*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 17 /*ScalarType.SINT32*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 17 /*ScalarType.SINT32*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 17 /*ScalarType.SINT32*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 17 /*ScalarType.SINT32*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 17 /*ScalarType.SINT32*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<SInt32Rules>): SInt32Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<SInt32Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SInt32Rules): SInt32Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional sint32 const */ 1:
                    message.const = reader.sint32();
                    break;
                case /* optional sint32 lt */ 2:
                    message.lt = reader.sint32();
                    break;
                case /* optional sint32 lte */ 3:
                    message.lte = reader.sint32();
                    break;
                case /* optional sint32 gt */ 4:
                    message.gt = reader.sint32();
                    break;
                case /* optional sint32 gte */ 5:
                    message.gte = reader.sint32();
                    break;
                case /* repeated sint32 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.sint32());
                    else
                        message.in.push(reader.sint32());
                    break;
                case /* repeated sint32 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.sint32());
                    else
                        message.notIn.push(reader.sint32());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: SInt32Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional sint32 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).sint32(message.const);
        /* optional sint32 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Varint).sint32(message.lt);
        /* optional sint32 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Varint).sint32(message.lte);
        /* optional sint32 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Varint).sint32(message.gt);
        /* optional sint32 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Varint).sint32(message.gte);
        /* repeated sint32 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Varint).sint32(message.in[i]);
        /* repeated sint32 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Varint).sint32(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.SInt32Rules
 */
export const SInt32Rules = new SInt32Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SInt64Rules$Type extends MessageType<SInt64Rules> {
    constructor() {
        super("validate.SInt64Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 18 /*ScalarType.SINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<SInt64Rules>): SInt64Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<SInt64Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SInt64Rules): SInt64Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional sint64 const */ 1:
                    message.const = reader.sint64().toBigInt();
                    break;
                case /* optional sint64 lt */ 2:
                    message.lt = reader.sint64().toBigInt();
                    break;
                case /* optional sint64 lte */ 3:
                    message.lte = reader.sint64().toBigInt();
                    break;
                case /* optional sint64 gt */ 4:
                    message.gt = reader.sint64().toBigInt();
                    break;
                case /* optional sint64 gte */ 5:
                    message.gte = reader.sint64().toBigInt();
                    break;
                case /* repeated sint64 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.sint64().toBigInt());
                    else
                        message.in.push(reader.sint64().toBigInt());
                    break;
                case /* repeated sint64 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.sint64().toBigInt());
                    else
                        message.notIn.push(reader.sint64().toBigInt());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: SInt64Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional sint64 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).sint64(message.const);
        /* optional sint64 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Varint).sint64(message.lt);
        /* optional sint64 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Varint).sint64(message.lte);
        /* optional sint64 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Varint).sint64(message.gt);
        /* optional sint64 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Varint).sint64(message.gte);
        /* repeated sint64 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Varint).sint64(message.in[i]);
        /* repeated sint64 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Varint).sint64(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.SInt64Rules
 */
export const SInt64Rules = new SInt64Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Fixed32Rules$Type extends MessageType<Fixed32Rules> {
    constructor() {
        super("validate.Fixed32Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 7 /*ScalarType.FIXED32*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 7 /*ScalarType.FIXED32*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 7 /*ScalarType.FIXED32*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 7 /*ScalarType.FIXED32*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 7 /*ScalarType.FIXED32*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 7 /*ScalarType.FIXED32*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 7 /*ScalarType.FIXED32*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<Fixed32Rules>): Fixed32Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<Fixed32Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Fixed32Rules): Fixed32Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional fixed32 const */ 1:
                    message.const = reader.fixed32();
                    break;
                case /* optional fixed32 lt */ 2:
                    message.lt = reader.fixed32();
                    break;
                case /* optional fixed32 lte */ 3:
                    message.lte = reader.fixed32();
                    break;
                case /* optional fixed32 gt */ 4:
                    message.gt = reader.fixed32();
                    break;
                case /* optional fixed32 gte */ 5:
                    message.gte = reader.fixed32();
                    break;
                case /* repeated fixed32 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.fixed32());
                    else
                        message.in.push(reader.fixed32());
                    break;
                case /* repeated fixed32 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.fixed32());
                    else
                        message.notIn.push(reader.fixed32());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: Fixed32Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional fixed32 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Bit32).fixed32(message.const);
        /* optional fixed32 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Bit32).fixed32(message.lt);
        /* optional fixed32 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Bit32).fixed32(message.lte);
        /* optional fixed32 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Bit32).fixed32(message.gt);
        /* optional fixed32 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Bit32).fixed32(message.gte);
        /* repeated fixed32 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Bit32).fixed32(message.in[i]);
        /* repeated fixed32 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Bit32).fixed32(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.Fixed32Rules
 */
export const Fixed32Rules = new Fixed32Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Fixed64Rules$Type extends MessageType<Fixed64Rules> {
    constructor() {
        super("validate.Fixed64Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 6 /*ScalarType.FIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 6 /*ScalarType.FIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 6 /*ScalarType.FIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 6 /*ScalarType.FIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 6 /*ScalarType.FIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 6 /*ScalarType.FIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 6 /*ScalarType.FIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<Fixed64Rules>): Fixed64Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<Fixed64Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Fixed64Rules): Fixed64Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional fixed64 const */ 1:
                    message.const = reader.fixed64().toBigInt();
                    break;
                case /* optional fixed64 lt */ 2:
                    message.lt = reader.fixed64().toBigInt();
                    break;
                case /* optional fixed64 lte */ 3:
                    message.lte = reader.fixed64().toBigInt();
                    break;
                case /* optional fixed64 gt */ 4:
                    message.gt = reader.fixed64().toBigInt();
                    break;
                case /* optional fixed64 gte */ 5:
                    message.gte = reader.fixed64().toBigInt();
                    break;
                case /* repeated fixed64 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.fixed64().toBigInt());
                    else
                        message.in.push(reader.fixed64().toBigInt());
                    break;
                case /* repeated fixed64 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.fixed64().toBigInt());
                    else
                        message.notIn.push(reader.fixed64().toBigInt());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: Fixed64Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional fixed64 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Bit64).fixed64(message.const);
        /* optional fixed64 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Bit64).fixed64(message.lt);
        /* optional fixed64 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Bit64).fixed64(message.lte);
        /* optional fixed64 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Bit64).fixed64(message.gt);
        /* optional fixed64 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Bit64).fixed64(message.gte);
        /* repeated fixed64 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Bit64).fixed64(message.in[i]);
        /* repeated fixed64 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Bit64).fixed64(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.Fixed64Rules
 */
export const Fixed64Rules = new Fixed64Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SFixed32Rules$Type extends MessageType<SFixed32Rules> {
    constructor() {
        super("validate.SFixed32Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 15 /*ScalarType.SFIXED32*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 15 /*ScalarType.SFIXED32*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 15 /*ScalarType.SFIXED32*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 15 /*ScalarType.SFIXED32*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 15 /*ScalarType.SFIXED32*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 15 /*ScalarType.SFIXED32*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 15 /*ScalarType.SFIXED32*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<SFixed32Rules>): SFixed32Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<SFixed32Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SFixed32Rules): SFixed32Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional sfixed32 const */ 1:
                    message.const = reader.sfixed32();
                    break;
                case /* optional sfixed32 lt */ 2:
                    message.lt = reader.sfixed32();
                    break;
                case /* optional sfixed32 lte */ 3:
                    message.lte = reader.sfixed32();
                    break;
                case /* optional sfixed32 gt */ 4:
                    message.gt = reader.sfixed32();
                    break;
                case /* optional sfixed32 gte */ 5:
                    message.gte = reader.sfixed32();
                    break;
                case /* repeated sfixed32 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.sfixed32());
                    else
                        message.in.push(reader.sfixed32());
                    break;
                case /* repeated sfixed32 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.sfixed32());
                    else
                        message.notIn.push(reader.sfixed32());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: SFixed32Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional sfixed32 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Bit32).sfixed32(message.const);
        /* optional sfixed32 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Bit32).sfixed32(message.lt);
        /* optional sfixed32 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Bit32).sfixed32(message.lte);
        /* optional sfixed32 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Bit32).sfixed32(message.gt);
        /* optional sfixed32 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Bit32).sfixed32(message.gte);
        /* repeated sfixed32 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Bit32).sfixed32(message.in[i]);
        /* repeated sfixed32 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Bit32).sfixed32(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.SFixed32Rules
 */
export const SFixed32Rules = new SFixed32Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SFixed64Rules$Type extends MessageType<SFixed64Rules> {
    constructor() {
        super("validate.SFixed64Rules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 16 /*ScalarType.SFIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "lt", kind: "scalar", opt: true, T: 16 /*ScalarType.SFIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "lte", kind: "scalar", opt: true, T: 16 /*ScalarType.SFIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "gt", kind: "scalar", opt: true, T: 16 /*ScalarType.SFIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 5, name: "gte", kind: "scalar", opt: true, T: 16 /*ScalarType.SFIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 6, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 16 /*ScalarType.SFIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 7, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 16 /*ScalarType.SFIXED64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 8, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<SFixed64Rules>): SFixed64Rules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<SFixed64Rules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SFixed64Rules): SFixed64Rules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional sfixed64 const */ 1:
                    message.const = reader.sfixed64().toBigInt();
                    break;
                case /* optional sfixed64 lt */ 2:
                    message.lt = reader.sfixed64().toBigInt();
                    break;
                case /* optional sfixed64 lte */ 3:
                    message.lte = reader.sfixed64().toBigInt();
                    break;
                case /* optional sfixed64 gt */ 4:
                    message.gt = reader.sfixed64().toBigInt();
                    break;
                case /* optional sfixed64 gte */ 5:
                    message.gte = reader.sfixed64().toBigInt();
                    break;
                case /* repeated sfixed64 in */ 6:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.sfixed64().toBigInt());
                    else
                        message.in.push(reader.sfixed64().toBigInt());
                    break;
                case /* repeated sfixed64 not_in */ 7:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.sfixed64().toBigInt());
                    else
                        message.notIn.push(reader.sfixed64().toBigInt());
                    break;
                case /* optional bool unauthorized */ 8:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 9:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: SFixed64Rules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional sfixed64 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Bit64).sfixed64(message.const);
        /* optional sfixed64 lt = 2; */
        if (message.lt !== undefined)
            writer.tag(2, WireType.Bit64).sfixed64(message.lt);
        /* optional sfixed64 lte = 3; */
        if (message.lte !== undefined)
            writer.tag(3, WireType.Bit64).sfixed64(message.lte);
        /* optional sfixed64 gt = 4; */
        if (message.gt !== undefined)
            writer.tag(4, WireType.Bit64).sfixed64(message.gt);
        /* optional sfixed64 gte = 5; */
        if (message.gte !== undefined)
            writer.tag(5, WireType.Bit64).sfixed64(message.gte);
        /* repeated sfixed64 in = 6; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(6, WireType.Bit64).sfixed64(message.in[i]);
        /* repeated sfixed64 not_in = 7; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(7, WireType.Bit64).sfixed64(message.notIn[i]);
        /* optional bool unauthorized = 8; */
        if (message.unauthorized !== undefined)
            writer.tag(8, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 9; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(9, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.SFixed64Rules
 */
export const SFixed64Rules = new SFixed64Rules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BoolRules$Type extends MessageType<BoolRules> {
    constructor() {
        super("validate.BoolRules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 2, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<BoolRules>): BoolRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<BoolRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BoolRules): BoolRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional bool const */ 1:
                    message.const = reader.bool();
                    break;
                case /* optional bool unauthorized */ 2:
                    message.unauthorized = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: BoolRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional bool const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).bool(message.const);
        /* optional bool unauthorized = 2; */
        if (message.unauthorized !== undefined)
            writer.tag(2, WireType.Varint).bool(message.unauthorized);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.BoolRules
 */
export const BoolRules = new BoolRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StringRules$Type extends MessageType<StringRules> {
    constructor() {
        super("validate.StringRules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
            { no: 19, name: "len", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "min_len", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "max_len", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 20, name: "len_bytes", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "min_bytes", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 5, name: "max_bytes", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 6, name: "pattern", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
            { no: 7, name: "prefix", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
            { no: 8, name: "suffix", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
            { no: 9, name: "contains", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
            { no: 23, name: "not_contains", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
            { no: 10, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
            { no: 11, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
            { no: 29, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 12, name: "email", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 13, name: "hostname", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 14, name: "ip", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 15, name: "ipv4", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 16, name: "ipv6", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 17, name: "uri", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 18, name: "uri_ref", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 21, name: "address", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 22, name: "uuid", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 24, name: "well_known_regex", kind: "enum", oneof: "wellKnown", T: () => ["validate.KnownRegex", KnownRegex] },
            { no: 26, name: "dateIso8601", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 27, name: "languageIso6391", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 28, name: "tzData", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 31, name: "countryCodeIso3166", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 32, name: "languageIso639", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 25, name: "strict", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 30, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<StringRules>): StringRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        message.wellKnown = { oneofKind: undefined };
        if (value !== undefined)
            reflectionMergePartial<StringRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StringRules): StringRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional string const */ 1:
                    message.const = reader.string();
                    break;
                case /* optional uint64 len */ 19:
                    message.len = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 min_len */ 2:
                    message.minLen = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 max_len */ 3:
                    message.maxLen = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 len_bytes */ 20:
                    message.lenBytes = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 min_bytes */ 4:
                    message.minBytes = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 max_bytes */ 5:
                    message.maxBytes = reader.uint64().toBigInt();
                    break;
                case /* optional string pattern */ 6:
                    message.pattern = reader.string();
                    break;
                case /* optional string prefix */ 7:
                    message.prefix = reader.string();
                    break;
                case /* optional string suffix */ 8:
                    message.suffix = reader.string();
                    break;
                case /* optional string contains */ 9:
                    message.contains = reader.string();
                    break;
                case /* optional string not_contains */ 23:
                    message.notContains = reader.string();
                    break;
                case /* repeated string in */ 10:
                    message.in.push(reader.string());
                    break;
                case /* repeated string not_in */ 11:
                    message.notIn.push(reader.string());
                    break;
                case /* optional bool unauthorized */ 29:
                    message.unauthorized = reader.bool();
                    break;
                case /* bool email */ 12:
                    message.wellKnown = {
                        oneofKind: "email",
                        email: reader.bool()
                    };
                    break;
                case /* bool hostname */ 13:
                    message.wellKnown = {
                        oneofKind: "hostname",
                        hostname: reader.bool()
                    };
                    break;
                case /* bool ip */ 14:
                    message.wellKnown = {
                        oneofKind: "ip",
                        ip: reader.bool()
                    };
                    break;
                case /* bool ipv4 */ 15:
                    message.wellKnown = {
                        oneofKind: "ipv4",
                        ipv4: reader.bool()
                    };
                    break;
                case /* bool ipv6 */ 16:
                    message.wellKnown = {
                        oneofKind: "ipv6",
                        ipv6: reader.bool()
                    };
                    break;
                case /* bool uri */ 17:
                    message.wellKnown = {
                        oneofKind: "uri",
                        uri: reader.bool()
                    };
                    break;
                case /* bool uri_ref */ 18:
                    message.wellKnown = {
                        oneofKind: "uriRef",
                        uriRef: reader.bool()
                    };
                    break;
                case /* bool address */ 21:
                    message.wellKnown = {
                        oneofKind: "address",
                        address: reader.bool()
                    };
                    break;
                case /* bool uuid */ 22:
                    message.wellKnown = {
                        oneofKind: "uuid",
                        uuid: reader.bool()
                    };
                    break;
                case /* validate.KnownRegex well_known_regex */ 24:
                    message.wellKnown = {
                        oneofKind: "wellKnownRegex",
                        wellKnownRegex: reader.int32()
                    };
                    break;
                case /* bool dateIso8601 */ 26:
                    message.wellKnown = {
                        oneofKind: "dateIso8601",
                        dateIso8601: reader.bool()
                    };
                    break;
                case /* bool languageIso6391 */ 27:
                    message.wellKnown = {
                        oneofKind: "languageIso6391",
                        languageIso6391: reader.bool()
                    };
                    break;
                case /* bool tzData */ 28:
                    message.wellKnown = {
                        oneofKind: "tzData",
                        tzData: reader.bool()
                    };
                    break;
                case /* bool countryCodeIso3166 */ 31:
                    message.wellKnown = {
                        oneofKind: "countryCodeIso3166",
                        countryCodeIso3166: reader.bool()
                    };
                    break;
                case /* bool languageIso639 */ 32:
                    message.wellKnown = {
                        oneofKind: "languageIso639",
                        languageIso639: reader.bool()
                    };
                    break;
                case /* optional bool strict */ 25:
                    message.strict = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 30:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: StringRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional string const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.LengthDelimited).string(message.const);
        /* optional uint64 len = 19; */
        if (message.len !== undefined)
            writer.tag(19, WireType.Varint).uint64(message.len);
        /* optional uint64 min_len = 2; */
        if (message.minLen !== undefined)
            writer.tag(2, WireType.Varint).uint64(message.minLen);
        /* optional uint64 max_len = 3; */
        if (message.maxLen !== undefined)
            writer.tag(3, WireType.Varint).uint64(message.maxLen);
        /* optional uint64 len_bytes = 20; */
        if (message.lenBytes !== undefined)
            writer.tag(20, WireType.Varint).uint64(message.lenBytes);
        /* optional uint64 min_bytes = 4; */
        if (message.minBytes !== undefined)
            writer.tag(4, WireType.Varint).uint64(message.minBytes);
        /* optional uint64 max_bytes = 5; */
        if (message.maxBytes !== undefined)
            writer.tag(5, WireType.Varint).uint64(message.maxBytes);
        /* optional string pattern = 6; */
        if (message.pattern !== undefined)
            writer.tag(6, WireType.LengthDelimited).string(message.pattern);
        /* optional string prefix = 7; */
        if (message.prefix !== undefined)
            writer.tag(7, WireType.LengthDelimited).string(message.prefix);
        /* optional string suffix = 8; */
        if (message.suffix !== undefined)
            writer.tag(8, WireType.LengthDelimited).string(message.suffix);
        /* optional string contains = 9; */
        if (message.contains !== undefined)
            writer.tag(9, WireType.LengthDelimited).string(message.contains);
        /* optional string not_contains = 23; */
        if (message.notContains !== undefined)
            writer.tag(23, WireType.LengthDelimited).string(message.notContains);
        /* repeated string in = 10; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(10, WireType.LengthDelimited).string(message.in[i]);
        /* repeated string not_in = 11; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(11, WireType.LengthDelimited).string(message.notIn[i]);
        /* optional bool unauthorized = 29; */
        if (message.unauthorized !== undefined)
            writer.tag(29, WireType.Varint).bool(message.unauthorized);
        /* bool email = 12; */
        if (message.wellKnown.oneofKind === "email")
            writer.tag(12, WireType.Varint).bool(message.wellKnown.email);
        /* bool hostname = 13; */
        if (message.wellKnown.oneofKind === "hostname")
            writer.tag(13, WireType.Varint).bool(message.wellKnown.hostname);
        /* bool ip = 14; */
        if (message.wellKnown.oneofKind === "ip")
            writer.tag(14, WireType.Varint).bool(message.wellKnown.ip);
        /* bool ipv4 = 15; */
        if (message.wellKnown.oneofKind === "ipv4")
            writer.tag(15, WireType.Varint).bool(message.wellKnown.ipv4);
        /* bool ipv6 = 16; */
        if (message.wellKnown.oneofKind === "ipv6")
            writer.tag(16, WireType.Varint).bool(message.wellKnown.ipv6);
        /* bool uri = 17; */
        if (message.wellKnown.oneofKind === "uri")
            writer.tag(17, WireType.Varint).bool(message.wellKnown.uri);
        /* bool uri_ref = 18; */
        if (message.wellKnown.oneofKind === "uriRef")
            writer.tag(18, WireType.Varint).bool(message.wellKnown.uriRef);
        /* bool address = 21; */
        if (message.wellKnown.oneofKind === "address")
            writer.tag(21, WireType.Varint).bool(message.wellKnown.address);
        /* bool uuid = 22; */
        if (message.wellKnown.oneofKind === "uuid")
            writer.tag(22, WireType.Varint).bool(message.wellKnown.uuid);
        /* validate.KnownRegex well_known_regex = 24; */
        if (message.wellKnown.oneofKind === "wellKnownRegex")
            writer.tag(24, WireType.Varint).int32(message.wellKnown.wellKnownRegex);
        /* bool dateIso8601 = 26; */
        if (message.wellKnown.oneofKind === "dateIso8601")
            writer.tag(26, WireType.Varint).bool(message.wellKnown.dateIso8601);
        /* bool languageIso6391 = 27; */
        if (message.wellKnown.oneofKind === "languageIso6391")
            writer.tag(27, WireType.Varint).bool(message.wellKnown.languageIso6391);
        /* bool tzData = 28; */
        if (message.wellKnown.oneofKind === "tzData")
            writer.tag(28, WireType.Varint).bool(message.wellKnown.tzData);
        /* bool countryCodeIso3166 = 31; */
        if (message.wellKnown.oneofKind === "countryCodeIso3166")
            writer.tag(31, WireType.Varint).bool(message.wellKnown.countryCodeIso3166);
        /* bool languageIso639 = 32; */
        if (message.wellKnown.oneofKind === "languageIso639")
            writer.tag(32, WireType.Varint).bool(message.wellKnown.languageIso639);
        /* optional bool strict = 25; */
        if (message.strict !== undefined)
            writer.tag(25, WireType.Varint).bool(message.strict);
        /* optional bool ignore_empty = 30; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(30, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.StringRules
 */
export const StringRules = new StringRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BytesRules$Type extends MessageType<BytesRules> {
    constructor() {
        super("validate.BytesRules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
            { no: 13, name: "len", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "min_len", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "max_len", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 4, name: "pattern", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
            { no: 5, name: "prefix", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
            { no: 6, name: "suffix", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
            { no: 7, name: "contains", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
            { no: 8, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
            { no: 9, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
            { no: 10, name: "ip", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 11, name: "ipv4", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 12, name: "ipv6", kind: "scalar", oneof: "wellKnown", T: 8 /*ScalarType.BOOL*/ },
            { no: 14, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<BytesRules>): BytesRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        message.wellKnown = { oneofKind: undefined };
        if (value !== undefined)
            reflectionMergePartial<BytesRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: BytesRules): BytesRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional bytes const */ 1:
                    message.const = reader.bytes();
                    break;
                case /* optional uint64 len */ 13:
                    message.len = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 min_len */ 2:
                    message.minLen = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 max_len */ 3:
                    message.maxLen = reader.uint64().toBigInt();
                    break;
                case /* optional string pattern */ 4:
                    message.pattern = reader.string();
                    break;
                case /* optional bytes prefix */ 5:
                    message.prefix = reader.bytes();
                    break;
                case /* optional bytes suffix */ 6:
                    message.suffix = reader.bytes();
                    break;
                case /* optional bytes contains */ 7:
                    message.contains = reader.bytes();
                    break;
                case /* repeated bytes in */ 8:
                    message.in.push(reader.bytes());
                    break;
                case /* repeated bytes not_in */ 9:
                    message.notIn.push(reader.bytes());
                    break;
                case /* bool ip */ 10:
                    message.wellKnown = {
                        oneofKind: "ip",
                        ip: reader.bool()
                    };
                    break;
                case /* bool ipv4 */ 11:
                    message.wellKnown = {
                        oneofKind: "ipv4",
                        ipv4: reader.bool()
                    };
                    break;
                case /* bool ipv6 */ 12:
                    message.wellKnown = {
                        oneofKind: "ipv6",
                        ipv6: reader.bool()
                    };
                    break;
                case /* optional bool ignore_empty */ 14:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: BytesRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional bytes const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.LengthDelimited).bytes(message.const);
        /* optional uint64 len = 13; */
        if (message.len !== undefined)
            writer.tag(13, WireType.Varint).uint64(message.len);
        /* optional uint64 min_len = 2; */
        if (message.minLen !== undefined)
            writer.tag(2, WireType.Varint).uint64(message.minLen);
        /* optional uint64 max_len = 3; */
        if (message.maxLen !== undefined)
            writer.tag(3, WireType.Varint).uint64(message.maxLen);
        /* optional string pattern = 4; */
        if (message.pattern !== undefined)
            writer.tag(4, WireType.LengthDelimited).string(message.pattern);
        /* optional bytes prefix = 5; */
        if (message.prefix !== undefined)
            writer.tag(5, WireType.LengthDelimited).bytes(message.prefix);
        /* optional bytes suffix = 6; */
        if (message.suffix !== undefined)
            writer.tag(6, WireType.LengthDelimited).bytes(message.suffix);
        /* optional bytes contains = 7; */
        if (message.contains !== undefined)
            writer.tag(7, WireType.LengthDelimited).bytes(message.contains);
        /* repeated bytes in = 8; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(8, WireType.LengthDelimited).bytes(message.in[i]);
        /* repeated bytes not_in = 9; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(9, WireType.LengthDelimited).bytes(message.notIn[i]);
        /* bool ip = 10; */
        if (message.wellKnown.oneofKind === "ip")
            writer.tag(10, WireType.Varint).bool(message.wellKnown.ip);
        /* bool ipv4 = 11; */
        if (message.wellKnown.oneofKind === "ipv4")
            writer.tag(11, WireType.Varint).bool(message.wellKnown.ipv4);
        /* bool ipv6 = 12; */
        if (message.wellKnown.oneofKind === "ipv6")
            writer.tag(12, WireType.Varint).bool(message.wellKnown.ipv6);
        /* optional bool ignore_empty = 14; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(14, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.BytesRules
 */
export const BytesRules = new BytesRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class EnumRules$Type extends MessageType<EnumRules> {
    constructor() {
        super("validate.EnumRules", [
            { no: 1, name: "const", kind: "scalar", opt: true, T: 5 /*ScalarType.INT32*/ },
            { no: 2, name: "defined_only", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 3, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ },
            { no: 4, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 5 /*ScalarType.INT32*/ },
            { no: 5, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 6, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<EnumRules>): EnumRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<EnumRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EnumRules): EnumRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional int32 const */ 1:
                    message.const = reader.int32();
                    break;
                case /* optional bool defined_only */ 2:
                    message.definedOnly = reader.bool();
                    break;
                case /* repeated int32 in */ 3:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.in.push(reader.int32());
                    else
                        message.in.push(reader.int32());
                    break;
                case /* repeated int32 not_in */ 4:
                    if (wireType === WireType.LengthDelimited)
                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
                            message.notIn.push(reader.int32());
                    else
                        message.notIn.push(reader.int32());
                    break;
                case /* optional bool unauthorized */ 5:
                    message.unauthorized = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 6:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: EnumRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional int32 const = 1; */
        if (message.const !== undefined)
            writer.tag(1, WireType.Varint).int32(message.const);
        /* optional bool defined_only = 2; */
        if (message.definedOnly !== undefined)
            writer.tag(2, WireType.Varint).bool(message.definedOnly);
        /* repeated int32 in = 3; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(3, WireType.Varint).int32(message.in[i]);
        /* repeated int32 not_in = 4; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(4, WireType.Varint).int32(message.notIn[i]);
        /* optional bool unauthorized = 5; */
        if (message.unauthorized !== undefined)
            writer.tag(5, WireType.Varint).bool(message.unauthorized);
        /* optional bool ignore_empty = 6; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(6, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.EnumRules
 */
export const EnumRules = new EnumRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MessageRules$Type extends MessageType<MessageRules> {
    constructor() {
        super("validate.MessageRules", [
            { no: 1, name: "skip", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 2, name: "required", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 3, name: "unauthorized", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<MessageRules>): MessageRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<MessageRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MessageRules): MessageRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional bool skip */ 1:
                    message.skip = reader.bool();
                    break;
                case /* optional bool required */ 2:
                    message.required = reader.bool();
                    break;
                case /* optional bool unauthorized */ 3:
                    message.unauthorized = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: MessageRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional bool skip = 1; */
        if (message.skip !== undefined)
            writer.tag(1, WireType.Varint).bool(message.skip);
        /* optional bool required = 2; */
        if (message.required !== undefined)
            writer.tag(2, WireType.Varint).bool(message.required);
        /* optional bool unauthorized = 3; */
        if (message.unauthorized !== undefined)
            writer.tag(3, WireType.Varint).bool(message.unauthorized);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.MessageRules
 */
export const MessageRules = new MessageRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class RepeatedRules$Type extends MessageType<RepeatedRules> {
    constructor() {
        super("validate.RepeatedRules", [
            { no: 1, name: "min_items", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "max_items", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "unique", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 4, name: "items", kind: "message", T: () => FieldRules },
            { no: 5, name: "uniqueBaseLV", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 6, name: "knownRefLV", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 7, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<RepeatedRules>): RepeatedRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<RepeatedRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RepeatedRules): RepeatedRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional uint64 min_items */ 1:
                    message.minItems = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 max_items */ 2:
                    message.maxItems = reader.uint64().toBigInt();
                    break;
                case /* optional bool unique */ 3:
                    message.unique = reader.bool();
                    break;
                case /* optional validate.FieldRules items */ 4:
                    message.items = FieldRules.internalBinaryRead(reader, reader.uint32(), options, message.items);
                    break;
                case /* optional bool uniqueBaseLV */ 5:
                    message.uniqueBaseLV = reader.bool();
                    break;
                case /* optional bool knownRefLV */ 6:
                    message.knownRefLV = reader.bool();
                    break;
                case /* optional bool ignore_empty */ 7:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: RepeatedRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional uint64 min_items = 1; */
        if (message.minItems !== undefined)
            writer.tag(1, WireType.Varint).uint64(message.minItems);
        /* optional uint64 max_items = 2; */
        if (message.maxItems !== undefined)
            writer.tag(2, WireType.Varint).uint64(message.maxItems);
        /* optional bool unique = 3; */
        if (message.unique !== undefined)
            writer.tag(3, WireType.Varint).bool(message.unique);
        /* optional validate.FieldRules items = 4; */
        if (message.items)
            FieldRules.internalBinaryWrite(message.items, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        /* optional bool uniqueBaseLV = 5; */
        if (message.uniqueBaseLV !== undefined)
            writer.tag(5, WireType.Varint).bool(message.uniqueBaseLV);
        /* optional bool knownRefLV = 6; */
        if (message.knownRefLV !== undefined)
            writer.tag(6, WireType.Varint).bool(message.knownRefLV);
        /* optional bool ignore_empty = 7; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(7, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.RepeatedRules
 */
export const RepeatedRules = new RepeatedRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MapRules$Type extends MessageType<MapRules> {
    constructor() {
        super("validate.MapRules", [
            { no: 1, name: "min_pairs", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 2, name: "max_pairs", kind: "scalar", opt: true, T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
            { no: 3, name: "no_sparse", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 4, name: "keys", kind: "message", T: () => FieldRules },
            { no: 5, name: "values", kind: "message", T: () => FieldRules },
            { no: 6, name: "ignore_empty", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ }
        ]);
    }
    create(value?: PartialMessage<MapRules>): MapRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<MapRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MapRules): MapRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional uint64 min_pairs */ 1:
                    message.minPairs = reader.uint64().toBigInt();
                    break;
                case /* optional uint64 max_pairs */ 2:
                    message.maxPairs = reader.uint64().toBigInt();
                    break;
                case /* optional bool no_sparse */ 3:
                    message.noSparse = reader.bool();
                    break;
                case /* optional validate.FieldRules keys */ 4:
                    message.keys = FieldRules.internalBinaryRead(reader, reader.uint32(), options, message.keys);
                    break;
                case /* optional validate.FieldRules values */ 5:
                    message.values = FieldRules.internalBinaryRead(reader, reader.uint32(), options, message.values);
                    break;
                case /* optional bool ignore_empty */ 6:
                    message.ignoreEmpty = reader.bool();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: MapRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional uint64 min_pairs = 1; */
        if (message.minPairs !== undefined)
            writer.tag(1, WireType.Varint).uint64(message.minPairs);
        /* optional uint64 max_pairs = 2; */
        if (message.maxPairs !== undefined)
            writer.tag(2, WireType.Varint).uint64(message.maxPairs);
        /* optional bool no_sparse = 3; */
        if (message.noSparse !== undefined)
            writer.tag(3, WireType.Varint).bool(message.noSparse);
        /* optional validate.FieldRules keys = 4; */
        if (message.keys)
            FieldRules.internalBinaryWrite(message.keys, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        /* optional validate.FieldRules values = 5; */
        if (message.values)
            FieldRules.internalBinaryWrite(message.values, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
        /* optional bool ignore_empty = 6; */
        if (message.ignoreEmpty !== undefined)
            writer.tag(6, WireType.Varint).bool(message.ignoreEmpty);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.MapRules
 */
export const MapRules = new MapRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AnyRules$Type extends MessageType<AnyRules> {
    constructor() {
        super("validate.AnyRules", [
            { no: 1, name: "required", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 2, name: "in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
            { no: 3, name: "not_in", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
        ]);
    }
    create(value?: PartialMessage<AnyRules>): AnyRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<AnyRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AnyRules): AnyRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional bool required */ 1:
                    message.required = reader.bool();
                    break;
                case /* repeated string in */ 2:
                    message.in.push(reader.string());
                    break;
                case /* repeated string not_in */ 3:
                    message.notIn.push(reader.string());
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: AnyRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional bool required = 1; */
        if (message.required !== undefined)
            writer.tag(1, WireType.Varint).bool(message.required);
        /* repeated string in = 2; */
        for (let i = 0; i < message.in.length; i++)
            writer.tag(2, WireType.LengthDelimited).string(message.in[i]);
        /* repeated string not_in = 3; */
        for (let i = 0; i < message.notIn.length; i++)
            writer.tag(3, WireType.LengthDelimited).string(message.notIn[i]);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.AnyRules
 */
export const AnyRules = new AnyRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DurationRules$Type extends MessageType<DurationRules> {
    constructor() {
        super("validate.DurationRules", [
            { no: 1, name: "required", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 2, name: "const", kind: "message", T: () => Duration },
            { no: 3, name: "lt", kind: "message", T: () => Duration },
            { no: 4, name: "lte", kind: "message", T: () => Duration },
            { no: 5, name: "gt", kind: "message", T: () => Duration },
            { no: 6, name: "gte", kind: "message", T: () => Duration },
            { no: 7, name: "in", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Duration },
            { no: 8, name: "not_in", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Duration }
        ]);
    }
    create(value?: PartialMessage<DurationRules>): DurationRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        message.in = [];
        message.notIn = [];
        if (value !== undefined)
            reflectionMergePartial<DurationRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DurationRules): DurationRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional bool required */ 1:
                    message.required = reader.bool();
                    break;
                case /* optional google.protobuf.Duration const */ 2:
                    message.const = Duration.internalBinaryRead(reader, reader.uint32(), options, message.const);
                    break;
                case /* optional google.protobuf.Duration lt */ 3:
                    message.lt = Duration.internalBinaryRead(reader, reader.uint32(), options, message.lt);
                    break;
                case /* optional google.protobuf.Duration lte */ 4:
                    message.lte = Duration.internalBinaryRead(reader, reader.uint32(), options, message.lte);
                    break;
                case /* optional google.protobuf.Duration gt */ 5:
                    message.gt = Duration.internalBinaryRead(reader, reader.uint32(), options, message.gt);
                    break;
                case /* optional google.protobuf.Duration gte */ 6:
                    message.gte = Duration.internalBinaryRead(reader, reader.uint32(), options, message.gte);
                    break;
                case /* repeated google.protobuf.Duration in */ 7:
                    message.in.push(Duration.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case /* repeated google.protobuf.Duration not_in */ 8:
                    message.notIn.push(Duration.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: DurationRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional bool required = 1; */
        if (message.required !== undefined)
            writer.tag(1, WireType.Varint).bool(message.required);
        /* optional google.protobuf.Duration const = 2; */
        if (message.const)
            Duration.internalBinaryWrite(message.const, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Duration lt = 3; */
        if (message.lt)
            Duration.internalBinaryWrite(message.lt, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Duration lte = 4; */
        if (message.lte)
            Duration.internalBinaryWrite(message.lte, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Duration gt = 5; */
        if (message.gt)
            Duration.internalBinaryWrite(message.gt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Duration gte = 6; */
        if (message.gte)
            Duration.internalBinaryWrite(message.gte, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
        /* repeated google.protobuf.Duration in = 7; */
        for (let i = 0; i < message.in.length; i++)
            Duration.internalBinaryWrite(message.in[i], writer.tag(7, WireType.LengthDelimited).fork(), options).join();
        /* repeated google.protobuf.Duration not_in = 8; */
        for (let i = 0; i < message.notIn.length; i++)
            Duration.internalBinaryWrite(message.notIn[i], writer.tag(8, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.DurationRules
 */
export const DurationRules = new DurationRules$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TimestampRules$Type extends MessageType<TimestampRules> {
    constructor() {
        super("validate.TimestampRules", [
            { no: 1, name: "required", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 2, name: "const", kind: "message", T: () => Timestamp },
            { no: 3, name: "lt", kind: "message", T: () => Timestamp },
            { no: 4, name: "lte", kind: "message", T: () => Timestamp },
            { no: 5, name: "gt", kind: "message", T: () => Timestamp },
            { no: 6, name: "gte", kind: "message", T: () => Timestamp },
            { no: 7, name: "lt_now", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 8, name: "gt_now", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
            { no: 9, name: "within", kind: "message", T: () => Duration }
        ]);
    }
    create(value?: PartialMessage<TimestampRules>): TimestampRules {
        const message = globalThis.Object.create((this.messagePrototype!));
        if (value !== undefined)
            reflectionMergePartial<TimestampRules>(this, message, value);
        return message;
    }
    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TimestampRules): TimestampRules {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* optional bool required */ 1:
                    message.required = reader.bool();
                    break;
                case /* optional google.protobuf.Timestamp const */ 2:
                    message.const = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.const);
                    break;
                case /* optional google.protobuf.Timestamp lt */ 3:
                    message.lt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.lt);
                    break;
                case /* optional google.protobuf.Timestamp lte */ 4:
                    message.lte = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.lte);
                    break;
                case /* optional google.protobuf.Timestamp gt */ 5:
                    message.gt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.gt);
                    break;
                case /* optional google.protobuf.Timestamp gte */ 6:
                    message.gte = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.gte);
                    break;
                case /* optional bool lt_now */ 7:
                    message.ltNow = reader.bool();
                    break;
                case /* optional bool gt_now */ 8:
                    message.gtNow = reader.bool();
                    break;
                case /* optional google.protobuf.Duration within */ 9:
                    message.within = Duration.internalBinaryRead(reader, reader.uint32(), options, message.within);
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message: TimestampRules, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
        /* optional bool required = 1; */
        if (message.required !== undefined)
            writer.tag(1, WireType.Varint).bool(message.required);
        /* optional google.protobuf.Timestamp const = 2; */
        if (message.const)
            Timestamp.internalBinaryWrite(message.const, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Timestamp lt = 3; */
        if (message.lt)
            Timestamp.internalBinaryWrite(message.lt, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Timestamp lte = 4; */
        if (message.lte)
            Timestamp.internalBinaryWrite(message.lte, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Timestamp gt = 5; */
        if (message.gt)
            Timestamp.internalBinaryWrite(message.gt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
        /* optional google.protobuf.Timestamp gte = 6; */
        if (message.gte)
            Timestamp.internalBinaryWrite(message.gte, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
        /* optional bool lt_now = 7; */
        if (message.ltNow !== undefined)
            writer.tag(7, WireType.Varint).bool(message.ltNow);
        /* optional bool gt_now = 8; */
        if (message.gtNow !== undefined)
            writer.tag(8, WireType.Varint).bool(message.gtNow);
        /* optional google.protobuf.Duration within = 9; */
        if (message.within)
            Duration.internalBinaryWrite(message.within, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message validate.TimestampRules
 */
export const TimestampRules = new TimestampRules$Type();
