// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file orderInput.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 { AttachmentSummary, ClaimSummary, DateTime, EntityID, EventHeader, MetadataElement, RequestProjectHeader, ResponseHeader } from "./shared_pb.js";
import { ETAbyExecutionflow, ExecutionflowSummary, OrderLine, OrderRequestedMilestones, ReferencedID, TradeTier } from "./tradeShared_pb.js";

/**
 * @generated from message api.OrderCreatedPayload
 */
export class OrderCreatedPayload extends Message<OrderCreatedPayload> {
  /**
   * Mandatory
   *
   * @generated from field: api.DateTime CreationDateTime = 1;
   */
  CreationDateTime?: DateTime;

  /**
   * Optional : Reference to a parent order (with reason)
   *
   * @generated from field: api.ReferencedID ParentOrder = 2;
   */
  ParentOrder?: ReferencedID;

  /**
   * @generated from field: string LanguageCodeISO6391 = 3;
   */
  LanguageCodeISO6391 = "";

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

  /**
   * Mandatory : definition of the order buyer
   *
   * @generated from field: api.TradeTier Buyer = 5;
   */
  Buyer?: TradeTier;

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

  /**
   * Where to ship the order from
   *
   * @generated from field: api.TradeTier ShipFrom = 7;
   */
  ShipFrom?: TradeTier;

  /**
   * Where to ship the order to
   *
   * @generated from field: api.TradeTier ShipTo = 8;
   */
  ShipTo?: TradeTier;

  /**
   * Definition of the order carrier
   *
   * @generated from field: api.TradeTier Carrier = 9;
   */
  Carrier?: TradeTier;

  /**
   * Type of carrier service
   *
   * @generated from field: string CarrierService = 12;
   */
  CarrierService = "";

  /**
   * @generated from field: api.OrderRequestedMilestones RequestedMilestones = 10;
   */
  RequestedMilestones?: OrderRequestedMilestones;

  /**
   * Lines of the order
   *
   * @generated from field: repeated api.OrderLine Lines = 11;
   */
  Lines: OrderLine[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.OrderCreatedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "CreationDateTime", kind: "message", T: DateTime },
    { no: 2, name: "ParentOrder", kind: "message", T: ReferencedID },
    { no: 3, name: "LanguageCodeISO6391", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 4, name: "MetaData", kind: "message", T: MetadataElement, repeated: true },
    { no: 5, name: "Buyer", kind: "message", T: TradeTier },
    { no: 6, name: "Seller", kind: "message", T: TradeTier },
    { no: 7, name: "ShipFrom", kind: "message", T: TradeTier },
    { no: 8, name: "ShipTo", kind: "message", T: TradeTier },
    { no: 9, name: "Carrier", kind: "message", T: TradeTier },
    { no: 12, name: "CarrierService", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "RequestedMilestones", kind: "message", T: OrderRequestedMilestones },
    { no: 11, name: "Lines", kind: "message", T: OrderLine, repeated: true },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.OrderExecutionflowDetectedPayload
 */
export class OrderExecutionflowDetectedPayload extends Message<OrderExecutionflowDetectedPayload> {
  /**
   * Mandatory
   *
   * @generated from field: api.DateTime CreationDateTime = 1;
   */
  CreationDateTime?: DateTime;

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

  /**
   * Where to ship the order from
   *
   * @generated from field: api.TradeTier ShipFrom = 7;
   */
  ShipFrom?: TradeTier;

  /**
   * Where to ship the order to
   *
   * @generated from field: api.TradeTier ShipTo = 8;
   */
  ShipTo?: TradeTier;

  /**
   * Definition of the order carrier
   *
   * @generated from field: api.TradeTier Carrier = 9;
   */
  Carrier?: TradeTier;

  /**
   * Type of carrier service
   *
   * @generated from field: string CarrierService = 12;
   */
  CarrierService = "";

  /**
   * @generated from field: api.OrderRequestedMilestones RequestedMilestones = 10;
   */
  RequestedMilestones?: OrderRequestedMilestones;

  /**
   * Lines of the order
   *
   * @generated from field: repeated api.OrderLine Lines = 11;
   */
  Lines: OrderLine[] = [];

  /**
   * @generated from field: repeated api.ExecutionflowSummary ExecutionflowSummary = 13;
   */
  ExecutionflowSummary: ExecutionflowSummary[] = [];

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.OrderExecutionflowDetectedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "CreationDateTime", kind: "message", T: DateTime },
    { no: 4, name: "MetaData", kind: "message", T: MetadataElement, repeated: true },
    { no: 7, name: "ShipFrom", kind: "message", T: TradeTier },
    { no: 8, name: "ShipTo", kind: "message", T: TradeTier },
    { no: 9, name: "Carrier", kind: "message", T: TradeTier },
    { no: 12, name: "CarrierService", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 10, name: "RequestedMilestones", kind: "message", T: OrderRequestedMilestones },
    { no: 11, name: "Lines", kind: "message", T: OrderLine, repeated: true },
    { no: 13, name: "ExecutionflowSummary", kind: "message", T: ExecutionflowSummary, repeated: true },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.OrderShipperAssignedPayload
 */
export class OrderShipperAssignedPayload extends Message<OrderShipperAssignedPayload> {
  /**
   * Where to ship the order from
   *
   * @generated from field: api.TradeTier ShipFrom = 1;
   */
  ShipFrom?: TradeTier;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.OrderRequestedDeliveryDateDefinedPayload
 */
export class OrderRequestedDeliveryDateDefinedPayload extends Message<OrderRequestedDeliveryDateDefinedPayload> {
  /**
   * @generated from field: api.DateTime RequestedDeliveryDateTime = 1;
   */
  RequestedDeliveryDateTime?: DateTime;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.OrderExecutionflowETAUpdatedPayload
 */
export class OrderExecutionflowETAUpdatedPayload extends Message<OrderExecutionflowETAUpdatedPayload> {
  /**
   * @generated from field: repeated api.ETAbyExecutionflow ExecutionflowETAs = 1;
   */
  ExecutionflowETAs: ETAbyExecutionflow[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.OrderCompletedPayload
 */
export class OrderCompletedPayload extends Message<OrderCompletedPayload> {
  /**
   * Mandatory
   *
   * @generated from field: api.DateTime ActualCompletionDateTime = 1;
   */
  ActualCompletionDateTime?: DateTime;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.OrderCarrierUpdatedPayload
 */
export class OrderCarrierUpdatedPayload extends Message<OrderCarrierUpdatedPayload> {
  /**
   * Definition of the order carrier
   *
   * @generated from field: api.TradeTier Carrier = 1;
   */
  Carrier?: TradeTier;

  /**
   * Type of carrier service
   *
   * @generated from field: string CarrierService = 2;
   */
  CarrierService = "";

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

