npm-core-sdk/rules_pb.ts

// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file rules.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 { EntityType } from "./shared_pb.js";

/**
 * @generated from enum api.RuleType
 */
export enum RuleType {
  /**
   * @generated from enum value: RULE_TYPE_PROJECT_UNKNOWN = 0;
   */
  PROJECT_UNKNOWN = 0,

  /**
   * @generated from enum value: RULE_TYPE_PROJECT_RESTRICTION = 1;
   */
  PROJECT_RESTRICTION = 1,

  /**
   * @generated from enum value: RULE_TYPE_PROJECT_PRUNE = 2;
   */
  PROJECT_PRUNE = 2,

  /**
   * @generated from enum value: RULE_TYPE_PROJECT_ANONYMIZE = 3;
   */
  PROJECT_ANONYMIZE = 3,
}
// Retrieve enum metadata with: proto3.getEnumType(RuleType)
proto3.util.setEnumType(RuleType, "api.RuleType", [
  { no: 0, name: "RULE_TYPE_PROJECT_UNKNOWN" },
  { no: 1, name: "RULE_TYPE_PROJECT_RESTRICTION" },
  { no: 2, name: "RULE_TYPE_PROJECT_PRUNE" },
  { no: 3, name: "RULE_TYPE_PROJECT_ANONYMIZE" },
]);

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

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

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

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

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

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

  /**
   * @generated from field: api.RuleType RuleType = 7;
   */
  RuleType = RuleType.PROJECT_UNKNOWN;

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.Rule";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "OrganisationID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Entity", kind: "enum", T: proto3.getEnumType(EntityType) },
    { no: 4, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Description", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "Definition", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 7, name: "RuleType", kind: "enum", T: proto3.getEnumType(RuleType) },
    { no: 8, name: "RuleTypeID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 9, name: "Status", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

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

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

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

  /**
   * @generated from field: api.RuleType RuleType = 4;
   */
  RuleType = RuleType.PROJECT_UNKNOWN;

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

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

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

  /**
   * Who created the rule, will be used as the commit's author when pushed to git
   *
   * @generated from field: string Issuer = 8;
   */
  Issuer = "";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * Who updated the rule, will be used as the commit's author when pushed to git
   *
   * @generated from field: string Issuer = 6;
   */
  Issuer = "";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.RuleType RuleType = 2;
   */
  RuleType = RuleType.PROJECT_UNKNOWN;

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

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

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

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

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

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

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

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

/**
 * @generated from message api.ListRulesResponse
 */
export class ListRulesResponse extends Message<ListRulesResponse> {
  /**
   * @generated from field: repeated api.Rule Rules = 1;
   */
  Rules: Rule[] = [];

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

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

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

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

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

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

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

  /**
   * Who updated the rule, will be used as the commit's author when pushed to git
   *
   * @generated from field: string Issuer = 2;
   */
  Issuer = "";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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