// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file handlingunitInput.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 { HandlingunitInformation, QuantifiedDatedGoodsByExeflow, QuantifiedGoodsByExeflow } from "./warehousingShared_pb.js";
import { AttachmentSummary, ClaimSummary, DateTime, EntityID, EventHeader, MetadataElement, RequestProjectHeader, ResponseHeader } from "./shared_pb.js";
import { TrackingSummary } from "./transportShared_pb.js";
import { ETA } from "./tradeShared_pb.js";

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

  /**
   * @generated from field: repeated api.QuantifiedGoodsByExeflow PreparedContents = 2;
   */
  PreparedContents: QuantifiedGoodsByExeflow[] = [];

  /**
   * 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 = 3;
   */
  MetaData: MetadataElement[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *
 * The first goal of this message is to give the content in terms of other Handlingunit placed into it.
 * For example you provide the Handlingunit ID of boxes placed on the current Pallet.
 *
 * The second goal is to provide the general information about the logisticUnit.
 *
 * @generated from message api.HandlingunitHUsAddedPayload
 */
export class HandlingunitHUsAddedPayload extends Message<HandlingunitHUsAddedPayload> {
  /**
   * @generated from field: api.HandlingunitInformation Information = 1;
   */
  Information?: HandlingunitInformation;

  /**
   * @generated from field: repeated string IncludedHandlingunitIDs = 3;
   */
  IncludedHandlingunitIDs: string[] = [];

  /**
   * 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 = 4;
   */
  MetaData: MetadataElement[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.HandlingunitHUsAddedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Information", kind: "message", T: HandlingunitInformation },
    { no: 3, name: "IncludedHandlingunitIDs", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 4, name: "MetaData", kind: "message", T: MetadataElement, repeated: true },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: repeated string TrackingIDs = 2;
   */
  TrackingIDs: string[] = [];

  /**
   * @generated from field: api.DateTime DispatchedDateTime = 10;
   */
  DispatchedDateTime?: DateTime;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.HandlingunitTrackingUpdatedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "CurrentTrackingSummary", kind: "message", T: TrackingSummary },
    { no: 2, name: "TrackingIDs", kind: "scalar", T: 9 /* ScalarType.STRING */, repeated: true },
    { no: 10, name: "DispatchedDateTime", kind: "message", T: DateTime },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.HandlingunitGoodsReceivedPayload
 */
export class HandlingunitGoodsReceivedPayload extends Message<HandlingunitGoodsReceivedPayload> {
  /**
   * @generated from field: repeated api.QuantifiedDatedGoodsByExeflow ReceivedContents = 1;
   */
  ReceivedContents: QuantifiedDatedGoodsByExeflow[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.HandlingunitMetaDataUpdatedPayload
 */
export class HandlingunitMetaDataUpdatedPayload extends Message<HandlingunitMetaDataUpdatedPayload> {
  /**
   * @generated from field: repeated api.MetadataElement MetaData = 6;
   */
  MetaData: MetadataElement[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

