// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file trackingInput.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 { TrackingEvent } from "./transportShared_pb.js";
import { AttachmentSummary, DateTime, EntityID, EventHeader, RequestProjectHeader, ResponseHeader } from "./shared_pb.js";
import { ETA, TradeTier } from "./tradeShared_pb.js";

/**
 * @generated from message api.TrackingNotifiedPayload
 */
export class TrackingNotifiedPayload extends Message<TrackingNotifiedPayload> {
  /**
   * @generated from field: repeated api.TrackingEvent Events = 1;
   */
  Events: TrackingEvent[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * This date should be the same as the date in the header
   *
   * @generated from field: api.DateTime DispatchedDateTime = 5;
   */
  DispatchedDateTime?: DateTime;

  /**
   * @generated from field: api.TradeTier HUCarrier = 6;
   */
  HUCarrier?: TradeTier;

  /**
   * @generated from field: api.TradeTier HUShipFrom = 7;
   */
  HUShipFrom?: TradeTier;

  /**
   * @generated from field: api.TradeTier HUShipTo = 8;
   */
  HUShipTo?: TradeTier;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.TrackingDispatchedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "HandlingunitID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "TrackingURL", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 5, name: "DispatchedDateTime", kind: "message", T: DateTime },
    { no: 6, name: "HUCarrier", kind: "message", T: TradeTier },
    { no: 7, name: "HUShipFrom", kind: "message", T: TradeTier },
    { no: 8, name: "HUShipTo", kind: "message", T: TradeTier },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.TradeTier HUCarrier = 6;
   */
  HUCarrier?: TradeTier;

  /**
   * @generated from field: api.TradeTier HUShipFrom = 7;
   */
  HUShipFrom?: TradeTier;

  /**
   * @generated from field: api.TradeTier HUShipTo = 8;
   */
  HUShipTo?: TradeTier;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.TrackingHULabeledPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "HandlingunitID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "TrackingURL", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 6, name: "HUCarrier", kind: "message", T: TradeTier },
    { no: 7, name: "HUShipFrom", kind: "message", T: TradeTier },
    { no: 8, name: "HUShipTo", kind: "message", T: TradeTier },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * @generated from field: api.TradeTier NextHUCarrier = 3;
   */
  NextHUCarrier?: TradeTier;

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

  /**
   * @generated from field: api.TradeTier NextHUShipTo = 5;
   */
  NextHUShipTo?: TradeTier;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.TrackingSwitchedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "NextTrackingID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 2, name: "NextTrackingURL", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "NextHUCarrier", kind: "message", T: TradeTier },
    { no: 4, name: "NextHUShipFrom", kind: "message", T: TradeTier },
    { no: 5, name: "NextHUShipTo", kind: "message", T: TradeTier },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *
 * trackingETAUpdated
 *
 * @generated from message api.TrackingETAUpdatedPayload
 */
export class TrackingETAUpdatedPayload extends Message<TrackingETAUpdatedPayload> {
  /**
   * The ETA for the tracked HU
   *
   * @generated from field: api.ETA TrackingETA = 1;
   */
  TrackingETA?: ETA;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

