// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file restrictions.proto (package api, syntax proto3)
/* eslint-disable */
// @ts-nocheck

import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
import { Message, proto3 } from "@bufbuild/protobuf";
import { Rule } from "./rules_pb.js";
import { EntityType, RequestProjectHeader } from "./shared_pb.js";

/**
 * @generated from enum api.RestrictionType
 */
export enum RestrictionType {
  /**
   * @generated from enum value: RESTRICTION_TYPE_UNKNOWN = 0;
   */
  UNKNOWN = 0,

  /**
   * @generated from enum value: RESTRICTION_TYPE_USER = 1;
   */
  USER = 1,

  /**
   * @generated from enum value: RESTRICTION_TYPE_PARTNER = 2;
   */
  PARTNER = 2,
}
// Retrieve enum metadata with: proto3.getEnumType(RestrictionType)
proto3.util.setEnumType(RestrictionType, "api.RestrictionType", [
  { no: 0, name: "RESTRICTION_TYPE_UNKNOWN" },
  { no: 1, name: "RESTRICTION_TYPE_USER" },
  { no: 2, name: "RESTRICTION_TYPE_PARTNER" },
]);

/**
 * @generated from enum api.RuleComputeFormat
 */
export enum RuleComputeFormat {
  /**
   * @generated from enum value: RULE_COMPUTE_FORMAT_UNKNOWN = 0;
   */
  UNKNOWN = 0,

  /**
   * @generated from enum value: RULE_COMPUTE_FORMAT_CH = 1;
   */
  CH = 1,

  /**
   * @generated from enum value: RULE_COMPUTE_FORMAT_OS = 2;
   */
  OS = 2,

  /**
   * @generated from enum value: RULE_COMPUTE_FORMAT_JQ = 3;
   */
  JQ = 3,
}
// Retrieve enum metadata with: proto3.getEnumType(RuleComputeFormat)
proto3.util.setEnumType(RuleComputeFormat, "api.RuleComputeFormat", [
  { no: 0, name: "RULE_COMPUTE_FORMAT_UNKNOWN" },
  { no: 1, name: "RULE_COMPUTE_FORMAT_CH" },
  { no: 2, name: "RULE_COMPUTE_FORMAT_OS" },
  { no: 3, name: "RULE_COMPUTE_FORMAT_JQ" },
]);

/**
 * @generated from message api.Restriction
 */
export class Restriction extends Message<Restriction> {
  /**
   * @generated from field: string ID = 1;
   */
  ID = "";

  /**
   * @generated from field: string ProjectID = 2;
   */
  ProjectID = "";

  /**
   * @generated from field: api.RestrictionType TargetType = 3;
   */
  TargetType = RestrictionType.UNKNOWN;

  /**
   * @generated from field: string Name = 4;
   */
  Name = "";

  /**
   * @generated from field: string Description = 5;
   */
  Description = "";

  /**
   * @generated from field: bool Status = 6;
   */
  Status = false;

  /**
   * @generated from field: repeated api.Rule Rules = 7;
   */
  Rules: Rule[] = [];

  /**
   * @generated from field: string UpdatedAt = 8;
   */
  UpdatedAt = "";

  /**
   * @generated from field: string CreatedAt = 9;
   */
  CreatedAt = "";

  constructor(data?: PartialMessage<Restriction>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.Restriction";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "ProjectID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "TargetType", kind: "enum", T: proto3.getEnumType(RestrictionType) },
    { no: 4, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "Status", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 7, name: "Rules", kind: "message", T: Rule, repeated: true },
    { no: 8, name: "UpdatedAt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 9, name: "CreatedAt", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): Restriction {
    return new Restriction().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): Restriction {
    return new Restriction().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): Restriction {
    return new Restriction().fromJsonString(jsonString, options);
  }

  static equals(a: Restriction | PlainMessage<Restriction> | undefined, b: Restriction | PlainMessage<Restriction> | undefined): boolean {
    return proto3.util.equals(Restriction, a, b);
  }
}

/**
 * @generated from message api.RuleComputeResult
 */
export class RuleComputeResult extends Message<RuleComputeResult> {
  /**
   * @generated from field: api.RuleComputeFormat Format = 1;
   */
  Format = RuleComputeFormat.UNKNOWN;

  /**
   * @generated from field: string Value = 2;
   */
  Value = "";

  constructor(data?: PartialMessage<RuleComputeResult>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RuleComputeResult";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Format", kind: "enum", T: proto3.getEnumType(RuleComputeFormat) },
    { no: 2, name: "Value", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RuleComputeResult {
    return new RuleComputeResult().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RuleComputeResult {
    return new RuleComputeResult().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RuleComputeResult {
    return new RuleComputeResult().fromJsonString(jsonString, options);
  }

  static equals(a: RuleComputeResult | PlainMessage<RuleComputeResult> | undefined, b: RuleComputeResult | PlainMessage<RuleComputeResult> | undefined): boolean {
    return proto3.util.equals(RuleComputeResult, a, b);
  }
}

/**
 * @generated from message api.RestrictionRule
 */
export class RestrictionRule extends Message<RestrictionRule> {
  /**
   * @generated from field: string Name = 1;
   */
  Name = "";

  /**
   * @generated from field: api.EntityType Entity = 2;
   */
  Entity = EntityType.UNKNOWN;

  /**
   * @generated from field: string Description = 3;
   */
  Description = "";

  /**
   * @generated from field: string Definition = 4;
   */
  Definition = "";

  constructor(data?: PartialMessage<RestrictionRule>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.RestrictionRule";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Entity", kind: "enum", T: proto3.getEnumType(EntityType) },
    { no: 3, name: "Description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Definition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): RestrictionRule {
    return new RestrictionRule().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): RestrictionRule {
    return new RestrictionRule().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): RestrictionRule {
    return new RestrictionRule().fromJsonString(jsonString, options);
  }

  static equals(a: RestrictionRule | PlainMessage<RestrictionRule> | undefined, b: RestrictionRule | PlainMessage<RestrictionRule> | undefined): boolean {
    return proto3.util.equals(RestrictionRule, a, b);
  }
}

/**
 * Create
 *
 * @generated from message api.CreateRestrictionRequest
 */
export class CreateRestrictionRequest extends Message<CreateRestrictionRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: api.RestrictionType TargetType = 2;
   */
  TargetType = RestrictionType.UNKNOWN;

  /**
   * @generated from field: string Name = 3;
   */
  Name = "";

  /**
   * @generated from field: string Description = 4;
   */
  Description = "";

  /**
   * @generated from field: repeated api.RestrictionRule Rules = 5;
   */
  Rules: RestrictionRule[] = [];

  constructor(data?: PartialMessage<CreateRestrictionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.CreateRestrictionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "TargetType", kind: "enum", T: proto3.getEnumType(RestrictionType) },
    { no: 3, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Rules", kind: "message", T: RestrictionRule, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateRestrictionRequest {
    return new CreateRestrictionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateRestrictionRequest {
    return new CreateRestrictionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateRestrictionRequest {
    return new CreateRestrictionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: CreateRestrictionRequest | PlainMessage<CreateRestrictionRequest> | undefined, b: CreateRestrictionRequest | PlainMessage<CreateRestrictionRequest> | undefined): boolean {
    return proto3.util.equals(CreateRestrictionRequest, a, b);
  }
}

/**
 * @generated from message api.CreateRestrictionResponse
 */
export class CreateRestrictionResponse extends Message<CreateRestrictionResponse> {
  /**
   * @generated from field: api.Restriction Restriction = 1;
   */
  Restriction?: Restriction;

  constructor(data?: PartialMessage<CreateRestrictionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.CreateRestrictionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Restriction", kind: "message", T: Restriction },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): CreateRestrictionResponse {
    return new CreateRestrictionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): CreateRestrictionResponse {
    return new CreateRestrictionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): CreateRestrictionResponse {
    return new CreateRestrictionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: CreateRestrictionResponse | PlainMessage<CreateRestrictionResponse> | undefined, b: CreateRestrictionResponse | PlainMessage<CreateRestrictionResponse> | undefined): boolean {
    return proto3.util.equals(CreateRestrictionResponse, a, b);
  }
}

/**
 * Update
 *
 * @generated from message api.UpdateRestrictionRequest
 */
export class UpdateRestrictionRequest extends Message<UpdateRestrictionRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: string RestrictionID = 2;
   */
  RestrictionID = "";

  /**
   * @generated from field: string Name = 3;
   */
  Name = "";

  /**
   * @generated from field: string Description = 4;
   */
  Description = "";

  /**
   * @generated from field: repeated api.RestrictionRule Rules = 5;
   */
  Rules: RestrictionRule[] = [];

  constructor(data?: PartialMessage<UpdateRestrictionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.UpdateRestrictionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "RestrictionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Rules", kind: "message", T: RestrictionRule, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateRestrictionRequest {
    return new UpdateRestrictionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateRestrictionRequest {
    return new UpdateRestrictionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateRestrictionRequest {
    return new UpdateRestrictionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateRestrictionRequest | PlainMessage<UpdateRestrictionRequest> | undefined, b: UpdateRestrictionRequest | PlainMessage<UpdateRestrictionRequest> | undefined): boolean {
    return proto3.util.equals(UpdateRestrictionRequest, a, b);
  }
}

/**
 * @generated from message api.UpdateRestrictionResponse
 */
export class UpdateRestrictionResponse extends Message<UpdateRestrictionResponse> {
  /**
   * @generated from field: api.Restriction Restriction = 1;
   */
  Restriction?: Restriction;

  constructor(data?: PartialMessage<UpdateRestrictionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.UpdateRestrictionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Restriction", kind: "message", T: Restriction },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): UpdateRestrictionResponse {
    return new UpdateRestrictionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): UpdateRestrictionResponse {
    return new UpdateRestrictionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): UpdateRestrictionResponse {
    return new UpdateRestrictionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: UpdateRestrictionResponse | PlainMessage<UpdateRestrictionResponse> | undefined, b: UpdateRestrictionResponse | PlainMessage<UpdateRestrictionResponse> | undefined): boolean {
    return proto3.util.equals(UpdateRestrictionResponse, a, b);
  }
}

/**
 * Get
 *
 * @generated from message api.GetRestrictionRequest
 */
export class GetRestrictionRequest extends Message<GetRestrictionRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: string RestrictionID = 2;
   */
  RestrictionID = "";

  constructor(data?: PartialMessage<GetRestrictionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetRestrictionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "RestrictionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRestrictionRequest {
    return new GetRestrictionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRestrictionRequest {
    return new GetRestrictionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRestrictionRequest {
    return new GetRestrictionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetRestrictionRequest | PlainMessage<GetRestrictionRequest> | undefined, b: GetRestrictionRequest | PlainMessage<GetRestrictionRequest> | undefined): boolean {
    return proto3.util.equals(GetRestrictionRequest, a, b);
  }
}

/**
 * @generated from message api.GetRestrictionResponse
 */
export class GetRestrictionResponse extends Message<GetRestrictionResponse> {
  /**
   * @generated from field: api.Restriction Restriction = 1;
   */
  Restriction?: Restriction;

  constructor(data?: PartialMessage<GetRestrictionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetRestrictionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Restriction", kind: "message", T: Restriction },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRestrictionResponse {
    return new GetRestrictionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRestrictionResponse {
    return new GetRestrictionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRestrictionResponse {
    return new GetRestrictionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetRestrictionResponse | PlainMessage<GetRestrictionResponse> | undefined, b: GetRestrictionResponse | PlainMessage<GetRestrictionResponse> | undefined): boolean {
    return proto3.util.equals(GetRestrictionResponse, a, b);
  }
}

/**
 * List
 *
 * @generated from message api.ListRestrictionsRequest
 */
export class ListRestrictionsRequest extends Message<ListRestrictionsRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: api.RestrictionType TargetType = 2;
   */
  TargetType = RestrictionType.UNKNOWN;

  constructor(data?: PartialMessage<ListRestrictionsRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListRestrictionsRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "TargetType", kind: "enum", T: proto3.getEnumType(RestrictionType) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListRestrictionsRequest {
    return new ListRestrictionsRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListRestrictionsRequest {
    return new ListRestrictionsRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListRestrictionsRequest {
    return new ListRestrictionsRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ListRestrictionsRequest | PlainMessage<ListRestrictionsRequest> | undefined, b: ListRestrictionsRequest | PlainMessage<ListRestrictionsRequest> | undefined): boolean {
    return proto3.util.equals(ListRestrictionsRequest, a, b);
  }
}

/**
 * @generated from message api.ListRestrictionsResponse
 */
export class ListRestrictionsResponse extends Message<ListRestrictionsResponse> {
  /**
   * @generated from field: repeated api.Restriction Restrictions = 1;
   */
  Restrictions: Restriction[] = [];

  constructor(data?: PartialMessage<ListRestrictionsResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ListRestrictionsResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Restrictions", kind: "message", T: Restriction, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ListRestrictionsResponse {
    return new ListRestrictionsResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ListRestrictionsResponse {
    return new ListRestrictionsResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ListRestrictionsResponse {
    return new ListRestrictionsResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ListRestrictionsResponse | PlainMessage<ListRestrictionsResponse> | undefined, b: ListRestrictionsResponse | PlainMessage<ListRestrictionsResponse> | undefined): boolean {
    return proto3.util.equals(ListRestrictionsResponse, a, b);
  }
}

/**
 * Delete
 *
 * @generated from message api.DeleteRestrictionRequest
 */
export class DeleteRestrictionRequest extends Message<DeleteRestrictionRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: string RestrictionID = 2;
   */
  RestrictionID = "";

  constructor(data?: PartialMessage<DeleteRestrictionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DeleteRestrictionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "RestrictionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteRestrictionRequest {
    return new DeleteRestrictionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteRestrictionRequest {
    return new DeleteRestrictionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteRestrictionRequest {
    return new DeleteRestrictionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteRestrictionRequest | PlainMessage<DeleteRestrictionRequest> | undefined, b: DeleteRestrictionRequest | PlainMessage<DeleteRestrictionRequest> | undefined): boolean {
    return proto3.util.equals(DeleteRestrictionRequest, a, b);
  }
}

/**
 * @generated from message api.DeleteRestrictionResponse
 */
export class DeleteRestrictionResponse extends Message<DeleteRestrictionResponse> {
  constructor(data?: PartialMessage<DeleteRestrictionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DeleteRestrictionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteRestrictionResponse {
    return new DeleteRestrictionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteRestrictionResponse {
    return new DeleteRestrictionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteRestrictionResponse {
    return new DeleteRestrictionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteRestrictionResponse | PlainMessage<DeleteRestrictionResponse> | undefined, b: DeleteRestrictionResponse | PlainMessage<DeleteRestrictionResponse> | undefined): boolean {
    return proto3.util.equals(DeleteRestrictionResponse, a, b);
  }
}

/**
 * Enable
 *
 * @generated from message api.EnableRestrictionRequest
 */
export class EnableRestrictionRequest extends Message<EnableRestrictionRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: string RestrictionID = 2;
   */
  RestrictionID = "";

  constructor(data?: PartialMessage<EnableRestrictionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.EnableRestrictionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "RestrictionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EnableRestrictionRequest {
    return new EnableRestrictionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EnableRestrictionRequest {
    return new EnableRestrictionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EnableRestrictionRequest {
    return new EnableRestrictionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: EnableRestrictionRequest | PlainMessage<EnableRestrictionRequest> | undefined, b: EnableRestrictionRequest | PlainMessage<EnableRestrictionRequest> | undefined): boolean {
    return proto3.util.equals(EnableRestrictionRequest, a, b);
  }
}

/**
 * @generated from message api.EnableRestrictionResponse
 */
export class EnableRestrictionResponse extends Message<EnableRestrictionResponse> {
  /**
   * @generated from field: api.Restriction Restriction = 1;
   */
  Restriction?: Restriction;

  constructor(data?: PartialMessage<EnableRestrictionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.EnableRestrictionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Restriction", kind: "message", T: Restriction },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): EnableRestrictionResponse {
    return new EnableRestrictionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): EnableRestrictionResponse {
    return new EnableRestrictionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): EnableRestrictionResponse {
    return new EnableRestrictionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: EnableRestrictionResponse | PlainMessage<EnableRestrictionResponse> | undefined, b: EnableRestrictionResponse | PlainMessage<EnableRestrictionResponse> | undefined): boolean {
    return proto3.util.equals(EnableRestrictionResponse, a, b);
  }
}

/**
 * Disable
 *
 * @generated from message api.DisableRestrictionRequest
 */
export class DisableRestrictionRequest extends Message<DisableRestrictionRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: string RestrictionID = 2;
   */
  RestrictionID = "";

  constructor(data?: PartialMessage<DisableRestrictionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DisableRestrictionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "RestrictionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DisableRestrictionRequest {
    return new DisableRestrictionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DisableRestrictionRequest {
    return new DisableRestrictionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DisableRestrictionRequest {
    return new DisableRestrictionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DisableRestrictionRequest | PlainMessage<DisableRestrictionRequest> | undefined, b: DisableRestrictionRequest | PlainMessage<DisableRestrictionRequest> | undefined): boolean {
    return proto3.util.equals(DisableRestrictionRequest, a, b);
  }
}

/**
 * @generated from message api.DisableRestrictionResponse
 */
export class DisableRestrictionResponse extends Message<DisableRestrictionResponse> {
  /**
   * @generated from field: api.Restriction Restriction = 1;
   */
  Restriction?: Restriction;

  constructor(data?: PartialMessage<DisableRestrictionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DisableRestrictionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Restriction", kind: "message", T: Restriction },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DisableRestrictionResponse {
    return new DisableRestrictionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DisableRestrictionResponse {
    return new DisableRestrictionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DisableRestrictionResponse {
    return new DisableRestrictionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DisableRestrictionResponse | PlainMessage<DisableRestrictionResponse> | undefined, b: DisableRestrictionResponse | PlainMessage<DisableRestrictionResponse> | undefined): boolean {
    return proto3.util.equals(DisableRestrictionResponse, a, b);
  }
}

/**
 * DeleteForProject
 *
 * @generated from message api.DeleteForProjectRestrictionRequest
 */
export class DeleteForProjectRestrictionRequest extends Message<DeleteForProjectRestrictionRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  constructor(data?: PartialMessage<DeleteForProjectRestrictionRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DeleteForProjectRestrictionRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteForProjectRestrictionRequest {
    return new DeleteForProjectRestrictionRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteForProjectRestrictionRequest {
    return new DeleteForProjectRestrictionRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteForProjectRestrictionRequest {
    return new DeleteForProjectRestrictionRequest().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteForProjectRestrictionRequest | PlainMessage<DeleteForProjectRestrictionRequest> | undefined, b: DeleteForProjectRestrictionRequest | PlainMessage<DeleteForProjectRestrictionRequest> | undefined): boolean {
    return proto3.util.equals(DeleteForProjectRestrictionRequest, a, b);
  }
}

/**
 * @generated from message api.DeleteForProjectRestrictionResponse
 */
export class DeleteForProjectRestrictionResponse extends Message<DeleteForProjectRestrictionResponse> {
  constructor(data?: PartialMessage<DeleteForProjectRestrictionResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.DeleteForProjectRestrictionResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): DeleteForProjectRestrictionResponse {
    return new DeleteForProjectRestrictionResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): DeleteForProjectRestrictionResponse {
    return new DeleteForProjectRestrictionResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DeleteForProjectRestrictionResponse {
    return new DeleteForProjectRestrictionResponse().fromJsonString(jsonString, options);
  }

  static equals(a: DeleteForProjectRestrictionResponse | PlainMessage<DeleteForProjectRestrictionResponse> | undefined, b: DeleteForProjectRestrictionResponse | PlainMessage<DeleteForProjectRestrictionResponse> | undefined): boolean {
    return proto3.util.equals(DeleteForProjectRestrictionResponse, a, b);
  }
}

/**
 * GetRulesJSONTree
 *
 * @generated from message api.GetRulesJSONTreeRequest
 */
export class GetRulesJSONTreeRequest extends Message<GetRulesJSONTreeRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: string RestrictionID = 2;
   */
  RestrictionID = "";

  constructor(data?: PartialMessage<GetRulesJSONTreeRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetRulesJSONTreeRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "RestrictionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRulesJSONTreeRequest {
    return new GetRulesJSONTreeRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRulesJSONTreeRequest {
    return new GetRulesJSONTreeRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRulesJSONTreeRequest {
    return new GetRulesJSONTreeRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetRulesJSONTreeRequest | PlainMessage<GetRulesJSONTreeRequest> | undefined, b: GetRulesJSONTreeRequest | PlainMessage<GetRulesJSONTreeRequest> | undefined): boolean {
    return proto3.util.equals(GetRulesJSONTreeRequest, a, b);
  }
}

/**
 * @generated from message api.GetRulesJSONTreeResponse
 */
export class GetRulesJSONTreeResponse extends Message<GetRulesJSONTreeResponse> {
  /**
   * @generated from field: string JSONTree = 1;
   */
  JSONTree = "";

  constructor(data?: PartialMessage<GetRulesJSONTreeResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetRulesJSONTreeResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "JSONTree", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRulesJSONTreeResponse {
    return new GetRulesJSONTreeResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRulesJSONTreeResponse {
    return new GetRulesJSONTreeResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRulesJSONTreeResponse {
    return new GetRulesJSONTreeResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetRulesJSONTreeResponse | PlainMessage<GetRulesJSONTreeResponse> | undefined, b: GetRulesJSONTreeResponse | PlainMessage<GetRulesJSONTreeResponse> | undefined): boolean {
    return proto3.util.equals(GetRulesJSONTreeResponse, a, b);
  }
}

/**
 * GetRulesJSONTree
 *
 * @generated from message api.GetRuleJSONTreeRequest
 */
export class GetRuleJSONTreeRequest extends Message<GetRuleJSONTreeRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: string RestrictionID = 2;
   */
  RestrictionID = "";

  /**
   * @generated from field: string Name = 3;
   */
  Name = "";

  /**
   * @generated from field: api.EntityType Entity = 4;
   */
  Entity = EntityType.UNKNOWN;

  constructor(data?: PartialMessage<GetRuleJSONTreeRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetRuleJSONTreeRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "RestrictionID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "Entity", kind: "enum", T: proto3.getEnumType(EntityType) },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRuleJSONTreeRequest {
    return new GetRuleJSONTreeRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRuleJSONTreeRequest {
    return new GetRuleJSONTreeRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRuleJSONTreeRequest {
    return new GetRuleJSONTreeRequest().fromJsonString(jsonString, options);
  }

  static equals(a: GetRuleJSONTreeRequest | PlainMessage<GetRuleJSONTreeRequest> | undefined, b: GetRuleJSONTreeRequest | PlainMessage<GetRuleJSONTreeRequest> | undefined): boolean {
    return proto3.util.equals(GetRuleJSONTreeRequest, a, b);
  }
}

/**
 * @generated from message api.GetRuleJSONTreeResponse
 */
export class GetRuleJSONTreeResponse extends Message<GetRuleJSONTreeResponse> {
  /**
   * @generated from field: string JSONTree = 1;
   */
  JSONTree = "";

  constructor(data?: PartialMessage<GetRuleJSONTreeResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.GetRuleJSONTreeResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "JSONTree", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetRuleJSONTreeResponse {
    return new GetRuleJSONTreeResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetRuleJSONTreeResponse {
    return new GetRuleJSONTreeResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetRuleJSONTreeResponse {
    return new GetRuleJSONTreeResponse().fromJsonString(jsonString, options);
  }

  static equals(a: GetRuleJSONTreeResponse | PlainMessage<GetRuleJSONTreeResponse> | undefined, b: GetRuleJSONTreeResponse | PlainMessage<GetRuleJSONTreeResponse> | undefined): boolean {
    return proto3.util.equals(GetRuleJSONTreeResponse, a, b);
  }
}

/**
 * Compute
 *
 * @generated from message api.ComputeRuleRequest
 */
export class ComputeRuleRequest extends Message<ComputeRuleRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: api.EntityType Entity = 2;
   */
  Entity = EntityType.UNKNOWN;

  /**
   * @generated from field: string UserID = 3;
   */
  UserID = "";

  /**
   * @generated from field: repeated api.RuleComputeFormat OutputFormats = 4;
   */
  OutputFormats: RuleComputeFormat[] = [];

  constructor(data?: PartialMessage<ComputeRuleRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ComputeRuleRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "Entity", kind: "enum", T: proto3.getEnumType(EntityType) },
    { no: 3, name: "UserID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "OutputFormats", kind: "enum", T: proto3.getEnumType(RuleComputeFormat), repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ComputeRuleRequest {
    return new ComputeRuleRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ComputeRuleRequest {
    return new ComputeRuleRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ComputeRuleRequest {
    return new ComputeRuleRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ComputeRuleRequest | PlainMessage<ComputeRuleRequest> | undefined, b: ComputeRuleRequest | PlainMessage<ComputeRuleRequest> | undefined): boolean {
    return proto3.util.equals(ComputeRuleRequest, a, b);
  }
}

/**
 * @generated from message api.ComputeRuleResponse
 */
export class ComputeRuleResponse extends Message<ComputeRuleResponse> {
  /**
   * @generated from field: repeated api.RuleComputeResult Results = 1;
   */
  Results: RuleComputeResult[] = [];

  constructor(data?: PartialMessage<ComputeRuleResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ComputeRuleResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Results", kind: "message", T: RuleComputeResult, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ComputeRuleResponse {
    return new ComputeRuleResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ComputeRuleResponse {
    return new ComputeRuleResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ComputeRuleResponse {
    return new ComputeRuleResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ComputeRuleResponse | PlainMessage<ComputeRuleResponse> | undefined, b: ComputeRuleResponse | PlainMessage<ComputeRuleResponse> | undefined): boolean {
    return proto3.util.equals(ComputeRuleResponse, a, b);
  }
}

/**
 * @generated from message api.ValidateRestrictionRuleRequest
 */
export class ValidateRestrictionRuleRequest extends Message<ValidateRestrictionRuleRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: api.RestrictionRule Rule = 2;
   */
  Rule?: RestrictionRule;

  constructor(data?: PartialMessage<ValidateRestrictionRuleRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ValidateRestrictionRuleRequest";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: RequestProjectHeader },
    { no: 2, name: "Rule", kind: "message", T: RestrictionRule },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ValidateRestrictionRuleRequest {
    return new ValidateRestrictionRuleRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ValidateRestrictionRuleRequest {
    return new ValidateRestrictionRuleRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ValidateRestrictionRuleRequest {
    return new ValidateRestrictionRuleRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ValidateRestrictionRuleRequest | PlainMessage<ValidateRestrictionRuleRequest> | undefined, b: ValidateRestrictionRuleRequest | PlainMessage<ValidateRestrictionRuleRequest> | undefined): boolean {
    return proto3.util.equals(ValidateRestrictionRuleRequest, a, b);
  }
}

/**
 * @generated from message api.ValidateRestrictionRuleResponse
 */
export class ValidateRestrictionRuleResponse extends Message<ValidateRestrictionRuleResponse> {
  constructor(data?: PartialMessage<ValidateRestrictionRuleResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ValidateRestrictionRuleResponse";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ValidateRestrictionRuleResponse {
    return new ValidateRestrictionRuleResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ValidateRestrictionRuleResponse {
    return new ValidateRestrictionRuleResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ValidateRestrictionRuleResponse {
    return new ValidateRestrictionRuleResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ValidateRestrictionRuleResponse | PlainMessage<ValidateRestrictionRuleResponse> | undefined, b: ValidateRestrictionRuleResponse | PlainMessage<ValidateRestrictionRuleResponse> | undefined): boolean {
    return proto3.util.equals(ValidateRestrictionRuleResponse, a, b);
  }
}

