// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file claimInput.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 { Amount, AttachmentSummary, ClaimClosure, ClaimCriticality, ClaimStatus, EntityID, EventHeader, MetadataElement, RequestProjectHeader, ResponseHeader } from "./shared_pb.js";

/**
 * Event Payload
 *
 * @generated from message api.ClaimCreatedPayload
 */
export class ClaimCreatedPayload extends Message<ClaimCreatedPayload> {
  /**
   * Identifier of the claim type
   *
   * @generated from field: string ClaimTypeID = 1;
   */
  ClaimTypeID = "";

  /**
   * Identifier of the targetted entity
   *
   * @generated from field: string EntityID = 2;
   */
  EntityID = "";

  /**
   * Contacts assigned on the claim
   *
   * @generated from field: repeated string Assignees = 5;
   */
  Assignees: string[] = [];

  /**
   * Amount of the claim
   *
   * @generated from field: api.Amount Amount = 6;
   */
  Amount?: Amount;

  /**
   * Metadata are characteristics specific to the project. They can be of several data form (string, integer, float, boolean or timestamp)
   *
   * @generated from field: repeated api.MetadataElement MetaData = 7;
   */
  MetaData: MetadataElement[] = [];

  /**
   * Title of the claim
   *
   * @generated from field: string Title = 8;
   */
  Title = "";

  /**
   * Criticality of the claim
   *
   * @generated from field: api.ClaimCriticality Criticality = 9;
   */
  Criticality = ClaimCriticality.UNKNOWN;

  /**
   * Identifier to display, because it may differ from the EntityID
   *
   * @generated from field: string DisplayID = 10;
   */
  DisplayID = "";

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimCreatedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "ClaimTypeID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "EntityID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "Assignees", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 6, name: "Amount", kind: "message", T: Amount },
    { no: 7, name: "MetaData", kind: "message", T: MetadataElement, repeated: true },
    { no: 8, name: "Title", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 9, name: "Criticality", kind: "enum", T: proto3.getEnumType(ClaimCriticality) },
    { no: 10, name: "DisplayID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimCreatedPayload Payload = 3;
   */
  Payload?: ClaimCreatedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimCreatedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimCreatedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimCreatedPayload Payload = 3;
   */
  Payload?: ClaimCreatedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimCreatedResponse
 */
export class ClaimCreatedResponse extends Message<ClaimCreatedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimCompletedPayload
 */
export class ClaimCompletedPayload extends Message<ClaimCompletedPayload> {
  /**
   * End comment of the claim
   *
   * @generated from field: string EndComment = 1;
   */
  EndComment = "";

  /**
   * Closure responsible and causes of the claim
   *
   * @generated from field: api.ClaimClosure Closure = 2;
   */
  Closure?: ClaimClosure;

  /**
   * Status of the claim
   *
   * @generated from field: api.ClaimStatus StatusCode = 3;
   */
  StatusCode = ClaimStatus.UNKNOWN;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimCompletedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "EndComment", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "Closure", kind: "message", T: ClaimClosure },
    { no: 3, name: "StatusCode", kind: "enum", T: proto3.getEnumType(ClaimStatus) },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimCompletedPayload Payload = 3;
   */
  Payload?: ClaimCompletedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimCompletedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimCompletedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimCompletedPayload Payload = 3;
   */
  Payload?: ClaimCompletedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimCompletedResponse
 */
export class ClaimCompletedResponse extends Message<ClaimCompletedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimCriticalityUpdatedPayload
 */
export class ClaimCriticalityUpdatedPayload extends Message<ClaimCriticalityUpdatedPayload> {
  /**
   * Criticality of the claim
   *
   * @generated from field: api.ClaimCriticality Criticality = 3;
   */
  Criticality = ClaimCriticality.UNKNOWN;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimCriticalityUpdatedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 3, name: "Criticality", kind: "enum", T: proto3.getEnumType(ClaimCriticality) },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimCriticalityUpdatedPayload Payload = 3;
   */
  Payload?: ClaimCriticalityUpdatedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimCriticalityUpdatedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimCriticalityUpdatedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimCriticalityUpdatedPayload Payload = 3;
   */
  Payload?: ClaimCriticalityUpdatedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimCriticalityUpdatedResponse
 */
export class ClaimCriticalityUpdatedResponse extends Message<ClaimCriticalityUpdatedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimStatusUpdatedPayload
 */
export class ClaimStatusUpdatedPayload extends Message<ClaimStatusUpdatedPayload> {
  /**
   * Status of the claim
   *
   * @generated from field: api.ClaimStatus StatusCode = 4;
   */
  StatusCode = ClaimStatus.UNKNOWN;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimStatusUpdatedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 4, name: "StatusCode", kind: "enum", T: proto3.getEnumType(ClaimStatus) },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimStatusUpdatedPayload Payload = 3;
   */
  Payload?: ClaimStatusUpdatedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimStatusUpdatedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimStatusUpdatedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimStatusUpdatedPayload Payload = 3;
   */
  Payload?: ClaimStatusUpdatedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimStatusUpdatedResponse
 */
export class ClaimStatusUpdatedResponse extends Message<ClaimStatusUpdatedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimAmountUpdatedPayload
 */
export class ClaimAmountUpdatedPayload extends Message<ClaimAmountUpdatedPayload> {
  /**
   * Amount of the claim
   *
   * @generated from field: api.Amount Amount = 1;
   */
  Amount?: Amount;

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAmountUpdatedPayload Payload = 3;
   */
  Payload?: ClaimAmountUpdatedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimAmountUpdatedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimAmountUpdatedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAmountUpdatedPayload Payload = 3;
   */
  Payload?: ClaimAmountUpdatedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimAmountUpdatedResponse
 */
export class ClaimAmountUpdatedResponse extends Message<ClaimAmountUpdatedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimAssigneesAddedPayload
 */
export class ClaimAssigneesAddedPayload extends Message<ClaimAssigneesAddedPayload> {
  /**
   * Contacts assigned on the claim
   *
   * @generated from field: repeated string Assignees = 7;
   */
  Assignees: string[] = [];

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAssigneesAddedPayload Payload = 3;
   */
  Payload?: ClaimAssigneesAddedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimAssigneesAddedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimAssigneesAddedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAssigneesAddedPayload Payload = 3;
   */
  Payload?: ClaimAssigneesAddedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimAssigneesAddedResponse
 */
export class ClaimAssigneesAddedResponse extends Message<ClaimAssigneesAddedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimAssigneesRemovedPayload
 */
export class ClaimAssigneesRemovedPayload extends Message<ClaimAssigneesRemovedPayload> {
  /**
   * Contacts removed from the claim
   *
   * @generated from field: repeated string RemovedAssignees = 7;
   */
  RemovedAssignees: string[] = [];

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAssigneesRemovedPayload Payload = 3;
   */
  Payload?: ClaimAssigneesRemovedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimAssigneesRemovedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimAssigneesRemovedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAssigneesRemovedPayload Payload = 3;
   */
  Payload?: ClaimAssigneesRemovedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimAssigneesRemovedResponse
 */
export class ClaimAssigneesRemovedResponse extends Message<ClaimAssigneesRemovedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * @generated from message api.ClaimAttachmentAddedPayload
 */
export class ClaimAttachmentAddedPayload extends Message<ClaimAttachmentAddedPayload> {
  /**
   * @generated from field: repeated api.AttachmentSummary Attachments = 1;
   */
  Attachments: AttachmentSummary[] = [];

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAttachmentAddedPayload Payload = 3;
   */
  Payload?: ClaimAttachmentAddedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimAttachmentAddedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimAttachmentAddedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAttachmentAddedPayload Payload = 3;
   */
  Payload?: ClaimAttachmentAddedPayload;

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * @generated from message api.ClaimAttachmentRemovedPayload
 */
export class ClaimAttachmentRemovedPayload extends Message<ClaimAttachmentRemovedPayload> {
  /**
   * @generated from field: repeated api.AttachmentSummary Attachments = 1;
   */
  Attachments: AttachmentSummary[] = [];

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAttachmentRemovedPayload Payload = 3;
   */
  Payload?: ClaimAttachmentRemovedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimAttachmentRemovedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimAttachmentRemovedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimAttachmentRemovedPayload Payload = 3;
   */
  Payload?: ClaimAttachmentRemovedPayload;

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimMetaDataUpdatedPayload
 */
export class ClaimMetaDataUpdatedPayload extends Message<ClaimMetaDataUpdatedPayload> {
  /**
   * Metadata are characteristics specific to the project. They can be of several data form (string, integer, float, boolean or timestamp)
   *
   * @generated from field: repeated api.MetadataElement MetaData = 1;
   */
  MetaData: MetadataElement[] = [];

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimMetaDataUpdatedPayload Payload = 3;
   */
  Payload?: ClaimMetaDataUpdatedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimMetaDataUpdatedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimMetaDataUpdatedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimMetaDataUpdatedPayload Payload = 3;
   */
  Payload?: ClaimMetaDataUpdatedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimMetaDataUpdatedResponse
 */
export class ClaimMetaDataUpdatedResponse extends Message<ClaimMetaDataUpdatedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimTitleUpdatedPayload
 */
export class ClaimTitleUpdatedPayload extends Message<ClaimTitleUpdatedPayload> {
  /**
   * Title of the claim
   *
   * @generated from field: string Title = 1;
   */
  Title = "";

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimTitleUpdatedPayload Payload = 3;
   */
  Payload?: ClaimTitleUpdatedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimTitleUpdatedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimTitleUpdatedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimTitleUpdatedPayload Payload = 3;
   */
  Payload?: ClaimTitleUpdatedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimTitleUpdatedResponse
 */
export class ClaimTitleUpdatedResponse extends Message<ClaimTitleUpdatedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ClaimMessageSentPayload
 */
export class ClaimMessageSentPayload extends Message<ClaimMessageSentPayload> {
  /**
   * Message content
   *
   * @generated from field: string Message = 1;
   */
  Message = "";

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimMessageSentPayload Payload = 3;
   */
  Payload?: ClaimMessageSentPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimMessageSentEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimMessageSentPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimMessageSentPayload Payload = 3;
   */
  Payload?: ClaimMessageSentPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimMessageSentResponse
 */
export class ClaimMessageSentResponse extends Message<ClaimMessageSentResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimDeletedPayload Payload = 3;
   */
  Payload?: ClaimDeletedPayload;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ClaimDeletedEvent";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Header", kind: "message", T: EventHeader },
    { no: 2, name: "ID", kind: "message", T: EntityID },
    { no: 3, name: "Payload", kind: "message", T: ClaimDeletedPayload },
  ]);

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

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

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

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

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

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ClaimDeletedPayload Payload = 3;
   */
  Payload?: ClaimDeletedPayload;

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

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

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

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

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

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

/**
 * API Response
 *
 * @generated from message api.ClaimDeletedResponse
 */
export class ClaimDeletedResponse extends Message<ClaimDeletedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

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

