// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file actorInput.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 { ActorSnapshot, ActorTypology, Address, CarrierService, IdType } from "./repositoryShared_pb.js";
import { AttachmentSummary, ClaimSummary, EntityID, EventHeader, MetadataElement, RequestProjectHeader, ResponseHeader } from "./shared_pb.js";

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

  /**
   * @generated from field: api.IdType IdType = 2;
   */
  IdType = IdType.IDTYPE_UNKNOWN;

  /**
   * @generated from field: repeated api.MetadataElement MetaData = 3;
   */
  MetaData: MetadataElement[] = [];

  /**
   * @generated from field: api.Address Address = 4;
   */
  Address?: Address;

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

  /**
   * @generated from field: string AdditionalInformation = 15;
   */
  AdditionalInformation = "";

  /**
   * @generated from field: api.ActorTypology Typology = 10;
   */
  Typology = ActorTypology.TYPOLOGY_UNKNOWN;

  /**
   * Must be a valid email address
   *
   * @generated from field: repeated string Emails = 12;
   */
  Emails: string[] = [];

  /**
   * @generated from field: repeated string Phones = 13;
   */
  Phones: string[] = [];

  /**
   * Can manage stock
   *
   * @generated from field: bool ManagedStock = 14;
   */
  ManagedStock = false;

  /**
   * Can be used as carrier
   *
   * @generated from field: bool IsCarrier = 16;
   */
  IsCarrier = false;

  /**
   * List of carrier services
   *
   * @generated from field: repeated api.CarrierService CarrierServices = 17;
   */
  CarrierServices: CarrierService[] = [];

  /**
   * @generated from field: bool IsShipToConnected = 18;
   */
  IsShipToConnected = false;

  /**
   * @generated from field: bool IsShipFromConnected = 19;
   */
  IsShipFromConnected = false;

  /**
   * Must be existing partner ID
   *
   * @generated from field: string ShipToPartnerAppID = 20;
   */
  ShipToPartnerAppID = "";

  /**
   * Must be existing partner ID
   *
   * @generated from field: string ShipFromPartnerAppID = 21;
   */
  ShipFromPartnerAppID = "";

  /**
   * @generated from field: string PhotoURI = 26;
   */
  PhotoURI = "";

  /**
   * Prefix used to create executionflow identifiers
   *
   * @generated from field: repeated string ConnectionIdentifierPrefixes = 28;
   */
  ConnectionIdentifierPrefixes: string[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorCreatedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "IdType", kind: "enum", T: proto3.getEnumType(IdType) },
    { no: 3, name: "MetaData", kind: "message", T: MetadataElement, repeated: true },
    { no: 4, name: "Address", kind: "message", T: Address },
    { no: 6, name: "PartnerID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 15, name: "AdditionalInformation", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "Typology", kind: "enum", T: proto3.getEnumType(ActorTypology) },
    { no: 12, name: "Emails", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 13, name: "Phones", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 14, name: "ManagedStock", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 16, name: "IsCarrier", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 17, name: "CarrierServices", kind: "message", T: CarrierService, repeated: true },
    { no: 18, name: "IsShipToConnected", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 19, name: "IsShipFromConnected", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 20, name: "ShipToPartnerAppID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 21, name: "ShipFromPartnerAppID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 26, name: "PhotoURI", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 28, name: "ConnectionIdentifierPrefixes", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorCreatedEvent";
  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: ActorCreatedPayload },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorCreatedRequest";
  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: ActorCreatedPayload },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorCreatedResponse";
  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>): ActorCreatedResponse {
    return new ActorCreatedResponse().fromBinary(bytes, options);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorDeletedEvent";
  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: ActorDeletedPayload },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorDeletedRequest";
  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: ActorDeletedPayload },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorDeletedResponse";
  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>): ActorDeletedResponse {
    return new ActorDeletedResponse().fromBinary(bytes, options);
  }

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

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

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

/**
 * Event Payload
 *
 * @generated from message api.ActorSnapshotCompletedPayload
 */
export class ActorSnapshotCompletedPayload extends Message<ActorSnapshotCompletedPayload> {
  /**
   * @generated from field: api.ActorSnapshot Snapshot = 1;
   */
  Snapshot?: ActorSnapshot;

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

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

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorSnapshotCompletedEvent";
  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: ActorSnapshotCompletedPayload },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorSnapshotCompletedRequest";
  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: ActorSnapshotCompletedPayload },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorSnapshotCompletedResponse";
  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>): ActorSnapshotCompletedResponse {
    return new ActorSnapshotCompletedResponse().fromBinary(bytes, options);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorAttachmentAddedEvent";
  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: ActorAttachmentAddedPayload },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorAttachmentAddedRequest";
  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: ActorAttachmentAddedPayload },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorAttachmentAddedResponse";
  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>): ActorAttachmentAddedResponse {
    return new ActorAttachmentAddedResponse().fromBinary(bytes, options);
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorAttachmentRemovedEvent";
  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: ActorAttachmentRemovedPayload },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorAttachmentRemovedRequest";
  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: ActorAttachmentRemovedPayload },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorAttachmentRemovedResponse";
  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>): ActorAttachmentRemovedResponse {
    return new ActorAttachmentRemovedResponse().fromBinary(bytes, options);
  }

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

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

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

/**
 * @generated from message api.ActorClaimAddedPayload
 */
export class ActorClaimAddedPayload extends Message<ActorClaimAddedPayload> {
  /**
   * @generated from field: repeated api.ClaimSummary Claims = 1;
   */
  Claims: ClaimSummary[] = [];

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

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

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorClaimAddedEvent";
  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: ActorClaimAddedPayload },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorClaimAddedRequest";
  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: ActorClaimAddedPayload },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorClaimAddedResponse";
  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>): ActorClaimAddedResponse {
    return new ActorClaimAddedResponse().fromBinary(bytes, options);
  }

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

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

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

/**
 * @generated from message api.ActorMetaDataUpdatedPayload
 */
export class ActorMetaDataUpdatedPayload extends Message<ActorMetaDataUpdatedPayload> {
  /**
   * 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<ActorMetaDataUpdatedPayload>) {
    super();
    proto3.util.initPartial(data, this);
  }

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

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorMetaDataUpdatedEvent";
  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: ActorMetaDataUpdatedPayload },
  ]);

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

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorMetaDataUpdatedRequest";
  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: ActorMetaDataUpdatedPayload },
  ]);

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

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

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

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

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

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ActorMetaDataUpdatedResponse";
  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>): ActorMetaDataUpdatedResponse {
    return new ActorMetaDataUpdatedResponse().fromBinary(bytes, options);
  }

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

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

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

