// @generated by protoc-gen-es v1.10.0 with parameter "target=ts"
// @generated from file executionflowInput.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 { ETA, ETAbyHU, ExeFlowLine, OrderRequestedMilestones, TradeTier } from "./tradeShared_pb.js";
import { HandlingunitSummary } from "./warehousingShared_pb.js";

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

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

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

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

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

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

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

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

  /**
   * Definition of trade. Executionflow lines. Defines the requested goods and the prepared goods
   *
   * @generated from field: repeated api.ExeFlowLine Lines = 9;
   */
  Lines: ExeFlowLine[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * Definition of trade. Executionflow lines. Defines the requested goods and the prepared goods
   *
   * @generated from field: repeated api.ExeFlowLine Lines = 9;
   */
  Lines: ExeFlowLine[] = [];

  /**
   * @generated from field: bool ShipFromAcked = 14;
   */
  ShipFromAcked = false;

  /**
   * @generated from field: bool ShipToAcked = 15;
   */
  ShipToAcked = false;

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

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowDetectedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "CreationDateTime", kind: "message", T: DateTime },
    { no: 2, name: "OrderID", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 3, name: "MetaData", kind: "message", T: MetadataElement, repeated: true },
    { no: 4, name: "ShipFrom", kind: "message", T: TradeTier },
    { no: 5, name: "ShipTo", kind: "message", T: TradeTier },
    { no: 6, name: "Carrier", kind: "message", T: TradeTier },
    { no: 7, name: "CarrierService", kind: "scalar", T: 9 /* ScalarType.STRING */ },
    { no: 8, name: "RequestedMilestones", kind: "message", T: OrderRequestedMilestones },
    { no: 9, name: "Lines", kind: "message", T: ExeFlowLine, repeated: true },
    { no: 14, name: "ShipFromAcked", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
    { no: 15, name: "ShipToAcked", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
  ]);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.ExecutionflowRedetectedEvent
 */
export class ExecutionflowRedetectedEvent extends Message<ExecutionflowRedetectedEvent> {
  /**
   * option (postAggMethods) = ""; // Here are listed the post aggregation methods to call when event message is aggregated
   * option (preAggMethods) = ""; // Here are listed the pre aggregation methods to call before event message is aggregated
   *
   * @generated from field: api.EventHeader Header = 1;
   */
  Header?: EventHeader;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.ExecutionflowShipFromAckedPayload
 */
export class ExecutionflowShipFromAckedPayload extends Message<ExecutionflowShipFromAckedPayload> {
  /**
   * @generated from field: bool ShipFromAcked = 1;
   */
  ShipFromAcked = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @generated from message api.ExecutionflowShipToAckedPayload
 */
export class ExecutionflowShipToAckedPayload extends Message<ExecutionflowShipToAckedPayload> {
  /**
   * @generated from field: bool ShipToAcked = 1;
   */
  ShipToAcked = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *
 * HUTrackingUpdated
 * - Inform the executionflow about the handlingunit tracking status.
 * - Update the handlingunit goods status with tracking.
 *
 * @generated from message api.ExecutionflowHUTrackingUpdatedPayload
 */
export class ExecutionflowHUTrackingUpdatedPayload extends Message<ExecutionflowHUTrackingUpdatedPayload> {
  /**
   * @generated from field: repeated api.HandlingunitSummary Handlingunits = 1;
   */
  Handlingunits: HandlingunitSummary[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *
 * HUETAUpdated
 * - Inform the executionflow about the handlingunit ETAs updated.
 *
 * Comments updated 2024/01/09
 *
 * @generated from message api.ExecutionflowHUETAUpdatedPayload
 */
export class ExecutionflowHUETAUpdatedPayload extends Message<ExecutionflowHUETAUpdatedPayload> {
  /**
   * @generated from field: repeated api.ETAbyHU HandlingunitETAs = 1;
   */
  HandlingunitETAs: ETAbyHU[] = [];

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 *
 * ETAUpdated
 * - Inform the executionflow about the ETA updated directly on the executionflow
 *
 * Comments updated 2024/01/09
 *
 * @generated from message api.ExecutionflowETAUpdatedPayload
 */
export class ExecutionflowETAUpdatedPayload extends Message<ExecutionflowETAUpdatedPayload> {
  /**
   * The ETA for the executionflow as given by WMS. this ETA will be aggregated with those coming from HUs
   *
   * @generated from field: api.ETA ExecutionflowETA = 1;
   */
  ExecutionflowETA?: ETA;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  constructor(data?: PartialMessage<ExecutionflowAttachmentRemovedEvent>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowAttachmentRemovedEvent";
  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: ExecutionflowAttachmentRemovedPayload },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowAttachmentRemovedEvent {
    return new ExecutionflowAttachmentRemovedEvent().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowAttachmentRemovedEvent {
    return new ExecutionflowAttachmentRemovedEvent().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowAttachmentRemovedEvent {
    return new ExecutionflowAttachmentRemovedEvent().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowAttachmentRemovedEvent | PlainMessage<ExecutionflowAttachmentRemovedEvent> | undefined, b: ExecutionflowAttachmentRemovedEvent | PlainMessage<ExecutionflowAttachmentRemovedEvent> | undefined): boolean {
    return proto3.util.equals(ExecutionflowAttachmentRemovedEvent, a, b);
  }
}

/**
 * @generated from message api.ExecutionflowAttachmentRemovedRequest
 */
export class ExecutionflowAttachmentRemovedRequest extends Message<ExecutionflowAttachmentRemovedRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ExecutionflowAttachmentRemovedPayload Payload = 3;
   */
  Payload?: ExecutionflowAttachmentRemovedPayload;

  constructor(data?: PartialMessage<ExecutionflowAttachmentRemovedRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowAttachmentRemovedRequest";
  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: ExecutionflowAttachmentRemovedPayload },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowAttachmentRemovedRequest {
    return new ExecutionflowAttachmentRemovedRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowAttachmentRemovedRequest {
    return new ExecutionflowAttachmentRemovedRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowAttachmentRemovedRequest {
    return new ExecutionflowAttachmentRemovedRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowAttachmentRemovedRequest | PlainMessage<ExecutionflowAttachmentRemovedRequest> | undefined, b: ExecutionflowAttachmentRemovedRequest | PlainMessage<ExecutionflowAttachmentRemovedRequest> | undefined): boolean {
    return proto3.util.equals(ExecutionflowAttachmentRemovedRequest, a, b);
  }
}

/**
 * @generated from message api.ExecutionflowAttachmentRemovedResponse
 */
export class ExecutionflowAttachmentRemovedResponse extends Message<ExecutionflowAttachmentRemovedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  constructor(data?: PartialMessage<ExecutionflowAttachmentRemovedResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowAttachmentRemovedResponse";
  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>): ExecutionflowAttachmentRemovedResponse {
    return new ExecutionflowAttachmentRemovedResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowAttachmentRemovedResponse {
    return new ExecutionflowAttachmentRemovedResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowAttachmentRemovedResponse {
    return new ExecutionflowAttachmentRemovedResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowAttachmentRemovedResponse | PlainMessage<ExecutionflowAttachmentRemovedResponse> | undefined, b: ExecutionflowAttachmentRemovedResponse | PlainMessage<ExecutionflowAttachmentRemovedResponse> | undefined): boolean {
    return proto3.util.equals(ExecutionflowAttachmentRemovedResponse, a, b);
  }
}

/**
 *
 * ClaimAdded : this message tells that a claim is added for the Executionflow
 *
 * @generated from message api.ExecutionflowClaimAddedPayload
 */
export class ExecutionflowClaimAddedPayload extends Message<ExecutionflowClaimAddedPayload> {
  /**
   * @generated from field: repeated api.ClaimSummary Claims = 1;
   */
  Claims: ClaimSummary[] = [];

  constructor(data?: PartialMessage<ExecutionflowClaimAddedPayload>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowClaimAddedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
    { no: 1, name: "Claims", kind: "message", T: ClaimSummary, repeated: true },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowClaimAddedPayload {
    return new ExecutionflowClaimAddedPayload().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedPayload {
    return new ExecutionflowClaimAddedPayload().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedPayload {
    return new ExecutionflowClaimAddedPayload().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowClaimAddedPayload | PlainMessage<ExecutionflowClaimAddedPayload> | undefined, b: ExecutionflowClaimAddedPayload | PlainMessage<ExecutionflowClaimAddedPayload> | undefined): boolean {
    return proto3.util.equals(ExecutionflowClaimAddedPayload, a, b);
  }
}

/**
 * @generated from message api.ExecutionflowClaimAddedEvent
 */
export class ExecutionflowClaimAddedEvent extends Message<ExecutionflowClaimAddedEvent> {
  /**
   * @generated from field: api.EventHeader Header = 1;
   */
  Header?: EventHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ExecutionflowClaimAddedPayload Payload = 3;
   */
  Payload?: ExecutionflowClaimAddedPayload;

  constructor(data?: PartialMessage<ExecutionflowClaimAddedEvent>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowClaimAddedEvent";
  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: ExecutionflowClaimAddedPayload },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowClaimAddedEvent {
    return new ExecutionflowClaimAddedEvent().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedEvent {
    return new ExecutionflowClaimAddedEvent().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedEvent {
    return new ExecutionflowClaimAddedEvent().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowClaimAddedEvent | PlainMessage<ExecutionflowClaimAddedEvent> | undefined, b: ExecutionflowClaimAddedEvent | PlainMessage<ExecutionflowClaimAddedEvent> | undefined): boolean {
    return proto3.util.equals(ExecutionflowClaimAddedEvent, a, b);
  }
}

/**
 * @generated from message api.ExecutionflowClaimAddedRequest
 */
export class ExecutionflowClaimAddedRequest extends Message<ExecutionflowClaimAddedRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ExecutionflowClaimAddedPayload Payload = 3;
   */
  Payload?: ExecutionflowClaimAddedPayload;

  constructor(data?: PartialMessage<ExecutionflowClaimAddedRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowClaimAddedRequest";
  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: ExecutionflowClaimAddedPayload },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowClaimAddedRequest {
    return new ExecutionflowClaimAddedRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedRequest {
    return new ExecutionflowClaimAddedRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedRequest {
    return new ExecutionflowClaimAddedRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowClaimAddedRequest | PlainMessage<ExecutionflowClaimAddedRequest> | undefined, b: ExecutionflowClaimAddedRequest | PlainMessage<ExecutionflowClaimAddedRequest> | undefined): boolean {
    return proto3.util.equals(ExecutionflowClaimAddedRequest, a, b);
  }
}

/**
 * @generated from message api.ExecutionflowClaimAddedResponse
 */
export class ExecutionflowClaimAddedResponse extends Message<ExecutionflowClaimAddedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  constructor(data?: PartialMessage<ExecutionflowClaimAddedResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowClaimAddedResponse";
  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>): ExecutionflowClaimAddedResponse {
    return new ExecutionflowClaimAddedResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedResponse {
    return new ExecutionflowClaimAddedResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowClaimAddedResponse {
    return new ExecutionflowClaimAddedResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowClaimAddedResponse | PlainMessage<ExecutionflowClaimAddedResponse> | undefined, b: ExecutionflowClaimAddedResponse | PlainMessage<ExecutionflowClaimAddedResponse> | undefined): boolean {
    return proto3.util.equals(ExecutionflowClaimAddedResponse, a, b);
  }
}

/**
 * Event Payload
 *
 * @generated from message api.ExecutionflowDeletedPayload
 */
export class ExecutionflowDeletedPayload extends Message<ExecutionflowDeletedPayload> {
  constructor(data?: PartialMessage<ExecutionflowDeletedPayload>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowDeletedPayload";
  static readonly fields: FieldList = proto3.util.newFieldList(() => [
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowDeletedPayload {
    return new ExecutionflowDeletedPayload().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowDeletedPayload {
    return new ExecutionflowDeletedPayload().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowDeletedPayload {
    return new ExecutionflowDeletedPayload().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowDeletedPayload | PlainMessage<ExecutionflowDeletedPayload> | undefined, b: ExecutionflowDeletedPayload | PlainMessage<ExecutionflowDeletedPayload> | undefined): boolean {
    return proto3.util.equals(ExecutionflowDeletedPayload, a, b);
  }
}

/**
 * Event message
 *
 * @generated from message api.ExecutionflowDeletedEvent
 */
export class ExecutionflowDeletedEvent extends Message<ExecutionflowDeletedEvent> {
  /**
   * @generated from field: api.EventHeader Header = 1;
   */
  Header?: EventHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ExecutionflowDeletedPayload Payload = 3;
   */
  Payload?: ExecutionflowDeletedPayload;

  constructor(data?: PartialMessage<ExecutionflowDeletedEvent>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowDeletedEvent";
  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: ExecutionflowDeletedPayload },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowDeletedEvent {
    return new ExecutionflowDeletedEvent().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowDeletedEvent {
    return new ExecutionflowDeletedEvent().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowDeletedEvent {
    return new ExecutionflowDeletedEvent().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowDeletedEvent | PlainMessage<ExecutionflowDeletedEvent> | undefined, b: ExecutionflowDeletedEvent | PlainMessage<ExecutionflowDeletedEvent> | undefined): boolean {
    return proto3.util.equals(ExecutionflowDeletedEvent, a, b);
  }
}

/**
 * API Request
 *
 * @generated from message api.ExecutionflowDeletedRequest
 */
export class ExecutionflowDeletedRequest extends Message<ExecutionflowDeletedRequest> {
  /**
   * @generated from field: api.RequestProjectHeader Header = 1;
   */
  Header?: RequestProjectHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  /**
   * @generated from field: api.ExecutionflowDeletedPayload Payload = 3;
   */
  Payload?: ExecutionflowDeletedPayload;

  constructor(data?: PartialMessage<ExecutionflowDeletedRequest>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowDeletedRequest";
  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: ExecutionflowDeletedPayload },
  ]);

  static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): ExecutionflowDeletedRequest {
    return new ExecutionflowDeletedRequest().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowDeletedRequest {
    return new ExecutionflowDeletedRequest().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowDeletedRequest {
    return new ExecutionflowDeletedRequest().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowDeletedRequest | PlainMessage<ExecutionflowDeletedRequest> | undefined, b: ExecutionflowDeletedRequest | PlainMessage<ExecutionflowDeletedRequest> | undefined): boolean {
    return proto3.util.equals(ExecutionflowDeletedRequest, a, b);
  }
}

/**
 * API Response
 *
 * @generated from message api.ExecutionflowDeletedResponse
 */
export class ExecutionflowDeletedResponse extends Message<ExecutionflowDeletedResponse> {
  /**
   * @generated from field: api.ResponseHeader Header = 1;
   */
  Header?: ResponseHeader;

  /**
   * @generated from field: api.EntityID ID = 2;
   */
  ID?: EntityID;

  constructor(data?: PartialMessage<ExecutionflowDeletedResponse>) {
    super();
    proto3.util.initPartial(data, this);
  }

  static readonly runtime: typeof proto3 = proto3;
  static readonly typeName = "api.ExecutionflowDeletedResponse";
  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>): ExecutionflowDeletedResponse {
    return new ExecutionflowDeletedResponse().fromBinary(bytes, options);
  }

  static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): ExecutionflowDeletedResponse {
    return new ExecutionflowDeletedResponse().fromJson(jsonValue, options);
  }

  static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): ExecutionflowDeletedResponse {
    return new ExecutionflowDeletedResponse().fromJsonString(jsonString, options);
  }

  static equals(a: ExecutionflowDeletedResponse | PlainMessage<ExecutionflowDeletedResponse> | undefined, b: ExecutionflowDeletedResponse | PlainMessage<ExecutionflowDeletedResponse> | undefined): boolean {
    return proto3.util.equals(ExecutionflowDeletedResponse, a, b);
  }
}

