// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file movementInput.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 { EnrichedGoods, QuantityInLV, StockMovement } from "./warehousingShared_pb.js";
import { ActorPayload } from "./actor_pb.js";
import { AttachmentSummary, ClaimSummary, EntityID, EventHeader, NoID, RequestProjectHeader, ResponseHeader } from "./shared_pb.js";

/**
 *
 * create the stock movement on the goods with the provided goods quantity.
 * This event is received from the WMS .
 *
 * This event is used when the Stock is physically moved from/into the warehouse to De/Increment the physical Stock counter of this goods.
 *
 * The ID part of the request is removed, because the Movement ID.RefID is built internally
 * A specific algorithm will be implemented on api-server and all actions which result this event.
 *
 * @generated from message api.MovementCreatedPayload
 */
export class MovementCreatedPayload extends Message<MovementCreatedPayload> {
  /**
   * @generated from field: api.EnrichedGoods Goods = 1;
   */
  Goods?: EnrichedGoods;

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

  /**
   * @generated from field: api.ActorPayload Actor = 3;
   */
  Actor?: ActorPayload;

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

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.MovementCreatedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Goods", kind: "message", T: EnrichedGoods },
    { no: 2, name: "ActorID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Actor", kind: "message", T: ActorPayload },
    { no: 4, name: "Movement", kind: "message", T: StockMovement },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.MovementCreatedRequest
 */
export class MovementCreatedRequest extends Message<MovementCreatedRequest> {
  /**
   * Header of the event request
   *
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

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

  /**
   * Content of the event request
   *
   * @generated from field: api.MovementCreatedPayload Payload = 3;
   */
  Payload?: MovementCreatedPayload;

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

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

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

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

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

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

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

  /**
   * Identifier of the movement the request event was applied on
   *
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

/**
 *
 * create the movement on the goods with the provided goods quantity.
 * This event is received internally
 *
 * This event is used when the Stock is physically moved from/into the warehouse to De/Increment the physical Stock counter of this goods.
 *
 * The ID part of the request is removed, because the Movement ID.RefID is built internally
 * A specific algorithm will be implemented on api-server and all actions which result this event.
 *
 * @generated from message api.MovementGeneratedPayload
 */
export class MovementGeneratedPayload extends Message<MovementGeneratedPayload> {
  /**
   * @generated from field: api.EnrichedGoods Goods = 1;
   */
  Goods?: EnrichedGoods;

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

  /**
   * @generated from field: api.ActorPayload Actor = 3;
   */
  Actor?: ActorPayload;

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

  /**
   * @generated from field: api.QuantityInLV QuantityInBaseLV = 8;
   */
  QuantityInBaseLV?: QuantityInLV;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.MovementGeneratedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Goods", kind: "message", T: EnrichedGoods },
    { no: 2, name: "ActorID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "Actor", kind: "message", T: ActorPayload },
    { no: 4, name: "Movement", kind: "message", T: StockMovement },
    { no: 8, name: "QuantityInBaseLV", kind: "message", T: QuantityInLV },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.MovementGeneratedRequest
 */
export class MovementGeneratedRequest extends Message<MovementGeneratedRequest> {
  /**
   * Header of the event request
   *
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

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

  /**
   * Content of the event request
   *
   * @generated from field: api.MovementGeneratedPayload Payload = 3;
   */
  Payload?: MovementGeneratedPayload;

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

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

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

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

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

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

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

  /**
   * Identifier of the movement the request event was applied on
   *
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

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

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

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

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

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

/**
 *
 * StockValueUpdated : this message tells what the stock value was just after the movement is registered
 *
 * @generated from message api.MovementStockValueUpdatedPayload
 */
export class MovementStockValueUpdatedPayload extends Message<MovementStockValueUpdatedPayload> {
  /**
   * Stock value juste after the movement was applied
   *
   * @generated from field: api.QuantityInLV QuantityInBaseLV = 1;
   */
  QuantityInBaseLV?: QuantityInLV;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *
 * AttachmentAdded : this message tells that an attachment is added for the handlingUnit
 *
 * @generated from message api.MovementAttachmentAddedPayload
 */
export class MovementAttachmentAddedPayload extends Message<MovementAttachmentAddedPayload> {
  /**
   * @generated from field: repeated api.AttachmentSummary Attachments = 1;
   */
  Attachments: AttachmentSummary[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *
 * AttachmentRemoved : this message tells that an attachment is removed for the handlingUnit
 *
 * @generated from message api.MovementAttachmentRemovedPayload
 */
export class MovementAttachmentRemovedPayload extends Message<MovementAttachmentRemovedPayload> {
  /**
   * @generated from field: repeated api.AttachmentSummary Attachments = 1;
   */
  Attachments: AttachmentSummary[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

