Latest generation

executionflow.ts

@@ -256,7 +256,7 @@ class ExecutionflowPayload$Type extends MessageType<ExecutionflowPayload> {
             { no: 6, name: "Carrier", kind: "message", localName: "Carrier", jsonName: "Carrier", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Definition of the order carrier" } } },
             { no: 7, name: "CarrierService", kind: "scalar", localName: "CarrierService", jsonName: "CarrierService", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Type of carrier service" }, "api.dataRestrictionKey": "Executionflow", "api.kpiItems": { Items: [{ Context: "Executionflow", Group: "executionflow", Queryable: true }] } } },
             { no: 8, name: "RequestedMilestones", kind: "message", localName: "RequestedMilestones", jsonName: "RequestedMilestones", T: () => OrderRequestedMilestones },
-            { no: 9, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExeFlowLine, options: { "api.aggKey": "LineID", "api.indexationSkip": true } },
+            { no: 9, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExeFlowLine, options: { "api.aggKey": "LineID", "api.aggAppend": "LinesAdded,LinesDetected", "api.indexationSkip": true } },
             { no: 11, name: "Handlingunits", kind: "message", localName: "Handlingunits", jsonName: "Handlingunits", repeat: 2 /*RepeatType.UNPACKED*/, T: () => HandlingunitSummary, options: { "api.aggKey": "HandlingunitID", "api.aggAppend": "HUContentUpdated,HUTrackingUpdated", "api.indexationSkip": true } },
             { no: 13, name: "Status", kind: "message", localName: "Status", jsonName: "Status", T: () => ExecutionflowStatusStruct, options: { "validate.rules": { message: { unauthorized: true } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { readOnly: true }, "api.indexationSkip": true } },
             { no: 14, name: "ShipFromAcked", kind: "scalar", localName: "ShipFromAcked", jsonName: "ShipFromAcked", T: 8 /*ScalarType.BOOL*/ },

executionflowAction.ts

@@ -10,6 +10,7 @@ import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
+import { OrderLine } from "./tradeShared";
 import { HandlingunitSummary } from "./warehousingShared";
 import { ExeFlowLine } from "./tradeShared";
 import { OrderRequestedMilestones } from "./tradeShared";
@@ -313,6 +314,42 @@ export interface ExecutionflowCreateDetectedOrder {
      */
     PreviousPayload?: ExecutionflowCreateDetectedOrderPayload;
 }
+/**
+ * @generated from protobuf message api.ExecutionflowPropagateLinesToOrderPayload
+ */
+export interface ExecutionflowPropagateLinesToOrderPayload {
+    /**
+     * Lines of the order
+     *
+     * @generated from protobuf field: repeated api.OrderLine Lines = 11
+     */
+    Lines: OrderLine[];
+}
+/**
+ * @generated from protobuf message api.ExecutionflowPropagateLinesToOrder
+ */
+export interface ExecutionflowPropagateLinesToOrder {
+    /**
+     * @generated from protobuf field: api.CommandHeader Header = 1
+     */
+    Header?: CommandHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.ExecutionflowPropagateLinesToOrderPayload Payload = 3
+     */
+    Payload?: ExecutionflowPropagateLinesToOrderPayload;
+    /**
+     * @generated from protobuf field: api.ExecutionflowPropagateLinesToOrderPayload EventPayload = 4
+     */
+    EventPayload?: ExecutionflowPropagateLinesToOrderPayload;
+    /**
+     * @generated from protobuf field: api.ExecutionflowPropagateLinesToOrderPayload PreviousPayload = 5
+     */
+    PreviousPayload?: ExecutionflowPropagateLinesToOrderPayload;
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class ExecutionflowMapSummaryToOrderPayload$Type extends MessageType<ExecutionflowMapSummaryToOrderPayload> {
     constructor() {
@@ -1028,3 +1065,124 @@ class ExecutionflowCreateDetectedOrder$Type extends MessageType<ExecutionflowCre
  * @generated MessageType for protobuf message api.ExecutionflowCreateDetectedOrder
  */
 export const ExecutionflowCreateDetectedOrder = new ExecutionflowCreateDetectedOrder$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowPropagateLinesToOrderPayload$Type extends MessageType<ExecutionflowPropagateLinesToOrderPayload> {
+    constructor() {
+        super("api.ExecutionflowPropagateLinesToOrderPayload", [
+            { no: 11, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OrderLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Lines of the order" }, "api.aggKey": "LineID" } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Propagates lines from Executionflow to Order" } }, "api.messageType": "Command", "api.payload": true, "api.action": "PropagateLinesToOrder" });
+    }
+    create(value?: PartialMessage<ExecutionflowPropagateLinesToOrderPayload>): ExecutionflowPropagateLinesToOrderPayload {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Lines = [];
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowPropagateLinesToOrderPayload>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowPropagateLinesToOrderPayload): ExecutionflowPropagateLinesToOrderPayload {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated api.OrderLine Lines */ 11:
+                    message.Lines.push(OrderLine.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowPropagateLinesToOrderPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated api.OrderLine Lines = 11; */
+        for (let i = 0; i < message.Lines.length; i++)
+            OrderLine.internalBinaryWrite(message.Lines[i], writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowPropagateLinesToOrderPayload
+ */
+export const ExecutionflowPropagateLinesToOrderPayload = new ExecutionflowPropagateLinesToOrderPayload$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowPropagateLinesToOrder$Type extends MessageType<ExecutionflowPropagateLinesToOrder> {
+    constructor() {
+        super("api.ExecutionflowPropagateLinesToOrder", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => CommandHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ExecutionflowPropagateLinesToOrderPayload },
+            { no: 4, name: "EventPayload", kind: "message", localName: "EventPayload", jsonName: "EventPayload", T: () => ExecutionflowPropagateLinesToOrderPayload },
+            { no: 5, name: "PreviousPayload", kind: "message", localName: "PreviousPayload", jsonName: "PreviousPayload", T: () => ExecutionflowPropagateLinesToOrderPayload }
+        ], { "api.messageType": "Command", "api.action": "PropagateLinesToOrder", "api.resultingEvent": "order.LinesDetected", "api.triggerEventFilters": "LinesAdded" });
+    }
+    create(value?: PartialMessage<ExecutionflowPropagateLinesToOrder>): ExecutionflowPropagateLinesToOrder {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowPropagateLinesToOrder>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowPropagateLinesToOrder): ExecutionflowPropagateLinesToOrder {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.CommandHeader Header */ 1:
+                    message.Header = CommandHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.ExecutionflowPropagateLinesToOrderPayload Payload */ 3:
+                    message.Payload = ExecutionflowPropagateLinesToOrderPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                case /* api.ExecutionflowPropagateLinesToOrderPayload EventPayload */ 4:
+                    message.EventPayload = ExecutionflowPropagateLinesToOrderPayload.internalBinaryRead(reader, reader.uint32(), options, message.EventPayload);
+                    break;
+                case /* api.ExecutionflowPropagateLinesToOrderPayload PreviousPayload */ 5:
+                    message.PreviousPayload = ExecutionflowPropagateLinesToOrderPayload.internalBinaryRead(reader, reader.uint32(), options, message.PreviousPayload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowPropagateLinesToOrder, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.CommandHeader Header = 1; */
+        if (message.Header)
+            CommandHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.ExecutionflowPropagateLinesToOrderPayload Payload = 3; */
+        if (message.Payload)
+            ExecutionflowPropagateLinesToOrderPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* api.ExecutionflowPropagateLinesToOrderPayload EventPayload = 4; */
+        if (message.EventPayload)
+            ExecutionflowPropagateLinesToOrderPayload.internalBinaryWrite(message.EventPayload, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* api.ExecutionflowPropagateLinesToOrderPayload PreviousPayload = 5; */
+        if (message.PreviousPayload)
+            ExecutionflowPropagateLinesToOrderPayload.internalBinaryWrite(message.PreviousPayload, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowPropagateLinesToOrder
+ */
+export const ExecutionflowPropagateLinesToOrder = new ExecutionflowPropagateLinesToOrder$Type();

executionflowInput.client.ts

@@ -4,6 +4,10 @@
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
 import { ExecutionflowInputAPI } from "./executionflowInput";
+import type { ExecutionflowLinesDetectedResponse } from "./executionflowInput";
+import type { ExecutionflowLinesDetectedRequest } from "./executionflowInput";
+import type { ExecutionflowLinesAddedResponse } from "./executionflowInput";
+import type { ExecutionflowLinesAddedRequest } from "./executionflowInput";
 import type { ExecutionflowDeletedResponse } from "./executionflowInput";
 import type { ExecutionflowDeletedRequest } from "./executionflowInput";
 import type { ExecutionflowClaimAddedResponse } from "./executionflowInput";
@@ -182,6 +186,14 @@ export interface IExecutionflowInputAPIClient {
      * @generated from protobuf rpc: Deleted
      */
     deleted(input: ExecutionflowDeletedRequest, options?: RpcOptions): UnaryCall<ExecutionflowDeletedRequest, ExecutionflowDeletedResponse>;
+    /**
+     * @generated from protobuf rpc: LinesAdded
+     */
+    linesAdded(input: ExecutionflowLinesAddedRequest, options?: RpcOptions): UnaryCall<ExecutionflowLinesAddedRequest, ExecutionflowLinesAddedResponse>;
+    /**
+     * @generated from protobuf rpc: LinesDetected
+     */
+    linesDetected(input: ExecutionflowLinesDetectedRequest, options?: RpcOptions): UnaryCall<ExecutionflowLinesDetectedRequest, ExecutionflowLinesDetectedResponse>;
 }
 /**
  *
@@ -391,4 +403,18 @@ export class ExecutionflowInputAPIClient implements IExecutionflowInputAPIClient
         const method = this.methods[27], opt = this._transport.mergeOptions(options);
         return stackIntercept<ExecutionflowDeletedRequest, ExecutionflowDeletedResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: LinesAdded
+     */
+    linesAdded(input: ExecutionflowLinesAddedRequest, options?: RpcOptions): UnaryCall<ExecutionflowLinesAddedRequest, ExecutionflowLinesAddedResponse> {
+        const method = this.methods[28], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ExecutionflowLinesAddedRequest, ExecutionflowLinesAddedResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: LinesDetected
+     */
+    linesDetected(input: ExecutionflowLinesDetectedRequest, options?: RpcOptions): UnaryCall<ExecutionflowLinesDetectedRequest, ExecutionflowLinesDetectedResponse> {
+        const method = this.methods[29], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ExecutionflowLinesDetectedRequest, ExecutionflowLinesDetectedResponse>("unary", this._transport, method, opt, input);
+    }
 }

executionflowInput.ts

@@ -1780,6 +1780,132 @@ export interface ExecutionflowDeletedResponse {
      */
     ID?: EntityID;
 }
+/**
+ * Event Payload
+ *
+ * @generated from protobuf message api.ExecutionflowLinesAddedPayload
+ */
+export interface ExecutionflowLinesAddedPayload {
+    /**
+     * @generated from protobuf field: repeated api.ExeFlowLine Lines = 1
+     */
+    Lines: ExeFlowLine[];
+}
+/**
+ * Event message
+ *
+ * @generated from protobuf message api.ExecutionflowLinesAddedEvent
+ */
+export interface ExecutionflowLinesAddedEvent {
+    /**
+     * @generated from protobuf field: api.EventHeader Header = 1
+     */
+    Header?: EventHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.ExecutionflowLinesAddedPayload Payload = 3
+     */
+    Payload?: ExecutionflowLinesAddedPayload;
+}
+/**
+ * API Request
+ *
+ * @generated from protobuf message api.ExecutionflowLinesAddedRequest
+ */
+export interface ExecutionflowLinesAddedRequest {
+    /**
+     * @generated from protobuf field: api.RequestProjectHeader Header = 1
+     */
+    Header?: RequestProjectHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.ExecutionflowLinesAddedPayload Payload = 3
+     */
+    Payload?: ExecutionflowLinesAddedPayload;
+}
+/**
+ * API Response
+ *
+ * @generated from protobuf message api.ExecutionflowLinesAddedResponse
+ */
+export interface ExecutionflowLinesAddedResponse {
+    /**
+     * @generated from protobuf field: api.ResponseHeader Header = 1
+     */
+    Header?: ResponseHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+}
+/**
+ * @generated from protobuf message api.ExecutionflowLinesDetectedPayload
+ */
+export interface ExecutionflowLinesDetectedPayload {
+    /**
+     * @generated from protobuf field: repeated api.ExeFlowLine Lines = 1
+     */
+    Lines: ExeFlowLine[];
+}
+/**
+ * Event message
+ *
+ * @generated from protobuf message api.ExecutionflowLinesDetectedEvent
+ */
+export interface ExecutionflowLinesDetectedEvent {
+    /**
+     * @generated from protobuf field: api.EventHeader Header = 1
+     */
+    Header?: EventHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.ExecutionflowLinesDetectedPayload Payload = 3
+     */
+    Payload?: ExecutionflowLinesDetectedPayload;
+}
+/**
+ * API Request
+ *
+ * @generated from protobuf message api.ExecutionflowLinesDetectedRequest
+ */
+export interface ExecutionflowLinesDetectedRequest {
+    /**
+     * @generated from protobuf field: api.RequestProjectHeader Header = 1
+     */
+    Header?: RequestProjectHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.ExecutionflowLinesDetectedPayload Payload = 3
+     */
+    Payload?: ExecutionflowLinesDetectedPayload;
+}
+/**
+ * API Response
+ *
+ * @generated from protobuf message api.ExecutionflowLinesDetectedResponse
+ */
+export interface ExecutionflowLinesDetectedResponse {
+    /**
+     * @generated from protobuf field: api.ResponseHeader Header = 1
+     */
+    Header?: ResponseHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class ExecutionflowCreatedPayload$Type extends MessageType<ExecutionflowCreatedPayload> {
     constructor() {
@@ -7945,6 +8071,446 @@ class ExecutionflowDeletedResponse$Type extends MessageType<ExecutionflowDeleted
  * @generated MessageType for protobuf message api.ExecutionflowDeletedResponse
  */
 export const ExecutionflowDeletedResponse = new ExecutionflowDeletedResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesAddedPayload$Type extends MessageType<ExecutionflowLinesAddedPayload> {
+    constructor() {
+        super("api.ExecutionflowLinesAddedPayload", [
+            { no: 1, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExeFlowLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Definition of trade. Executionflow lines. Defines the requested goods and the prepared goods" }, "api.aggKey": "LineID" } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesAddedPayload>): ExecutionflowLinesAddedPayload {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Lines = [];
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesAddedPayload>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesAddedPayload): ExecutionflowLinesAddedPayload {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated api.ExeFlowLine Lines */ 1:
+                    message.Lines.push(ExeFlowLine.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesAddedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated api.ExeFlowLine Lines = 1; */
+        for (let i = 0; i < message.Lines.length; i++)
+            ExeFlowLine.internalBinaryWrite(message.Lines[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesAddedPayload
+ */
+export const ExecutionflowLinesAddedPayload = new ExecutionflowLinesAddedPayload$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesAddedEvent$Type extends MessageType<ExecutionflowLinesAddedEvent> {
+    constructor() {
+        super("api.ExecutionflowLinesAddedEvent", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ExecutionflowLinesAddedPayload }
+        ], { "api.messageType": "Event", "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesAddedEvent>): ExecutionflowLinesAddedEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesAddedEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesAddedEvent): ExecutionflowLinesAddedEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.EventHeader Header */ 1:
+                    message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.ExecutionflowLinesAddedPayload Payload */ 3:
+                    message.Payload = ExecutionflowLinesAddedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.EventHeader Header = 1; */
+        if (message.Header)
+            EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.ExecutionflowLinesAddedPayload Payload = 3; */
+        if (message.Payload)
+            ExecutionflowLinesAddedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesAddedEvent
+ */
+export const ExecutionflowLinesAddedEvent = new ExecutionflowLinesAddedEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesAddedRequest$Type extends MessageType<ExecutionflowLinesAddedRequest> {
+    constructor() {
+        super("api.ExecutionflowLinesAddedRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ExecutionflowLinesAddedPayload }
+        ], { "api.messageType": "Request", "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesAddedRequest>): ExecutionflowLinesAddedRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesAddedRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesAddedRequest): ExecutionflowLinesAddedRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestProjectHeader Header */ 1:
+                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.ExecutionflowLinesAddedPayload Payload */ 3:
+                    message.Payload = ExecutionflowLinesAddedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesAddedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestProjectHeader Header = 1; */
+        if (message.Header)
+            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.ExecutionflowLinesAddedPayload Payload = 3; */
+        if (message.Payload)
+            ExecutionflowLinesAddedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesAddedRequest
+ */
+export const ExecutionflowLinesAddedRequest = new ExecutionflowLinesAddedRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesAddedResponse$Type extends MessageType<ExecutionflowLinesAddedResponse> {
+    constructor() {
+        super("api.ExecutionflowLinesAddedResponse", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
+        ], { "api.messageType": "Response", "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesAddedResponse>): ExecutionflowLinesAddedResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesAddedResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesAddedResponse): ExecutionflowLinesAddedResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.ResponseHeader Header */ 1:
+                    message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesAddedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.ResponseHeader Header = 1; */
+        if (message.Header)
+            ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesAddedResponse
+ */
+export const ExecutionflowLinesAddedResponse = new ExecutionflowLinesAddedResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesDetectedPayload$Type extends MessageType<ExecutionflowLinesDetectedPayload> {
+    constructor() {
+        super("api.ExecutionflowLinesDetectedPayload", [
+            { no: 1, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExeFlowLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Definition of trade. Executionflow lines. Defines the requested goods and the prepared goods" }, "api.aggKey": "LineID" } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesDetectedPayload>): ExecutionflowLinesDetectedPayload {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Lines = [];
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesDetectedPayload>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesDetectedPayload): ExecutionflowLinesDetectedPayload {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated api.ExeFlowLine Lines */ 1:
+                    message.Lines.push(ExeFlowLine.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesDetectedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated api.ExeFlowLine Lines = 1; */
+        for (let i = 0; i < message.Lines.length; i++)
+            ExeFlowLine.internalBinaryWrite(message.Lines[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesDetectedPayload
+ */
+export const ExecutionflowLinesDetectedPayload = new ExecutionflowLinesDetectedPayload$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesDetectedEvent$Type extends MessageType<ExecutionflowLinesDetectedEvent> {
+    constructor() {
+        super("api.ExecutionflowLinesDetectedEvent", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ExecutionflowLinesDetectedPayload }
+        ], { "api.messageType": "Event", "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesDetectedEvent>): ExecutionflowLinesDetectedEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesDetectedEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesDetectedEvent): ExecutionflowLinesDetectedEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.EventHeader Header */ 1:
+                    message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.ExecutionflowLinesDetectedPayload Payload */ 3:
+                    message.Payload = ExecutionflowLinesDetectedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesDetectedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.EventHeader Header = 1; */
+        if (message.Header)
+            EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.ExecutionflowLinesDetectedPayload Payload = 3; */
+        if (message.Payload)
+            ExecutionflowLinesDetectedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesDetectedEvent
+ */
+export const ExecutionflowLinesDetectedEvent = new ExecutionflowLinesDetectedEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesDetectedRequest$Type extends MessageType<ExecutionflowLinesDetectedRequest> {
+    constructor() {
+        super("api.ExecutionflowLinesDetectedRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ExecutionflowLinesDetectedPayload }
+        ], { "api.messageType": "Request", "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesDetectedRequest>): ExecutionflowLinesDetectedRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesDetectedRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesDetectedRequest): ExecutionflowLinesDetectedRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestProjectHeader Header */ 1:
+                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.ExecutionflowLinesDetectedPayload Payload */ 3:
+                    message.Payload = ExecutionflowLinesDetectedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesDetectedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestProjectHeader Header = 1; */
+        if (message.Header)
+            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.ExecutionflowLinesDetectedPayload Payload = 3; */
+        if (message.Payload)
+            ExecutionflowLinesDetectedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesDetectedRequest
+ */
+export const ExecutionflowLinesDetectedRequest = new ExecutionflowLinesDetectedRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionflowLinesDetectedResponse$Type extends MessageType<ExecutionflowLinesDetectedResponse> {
+    constructor() {
+        super("api.ExecutionflowLinesDetectedResponse", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
+        ], { "api.messageType": "Response", "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<ExecutionflowLinesDetectedResponse>): ExecutionflowLinesDetectedResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionflowLinesDetectedResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowLinesDetectedResponse): ExecutionflowLinesDetectedResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.ResponseHeader Header */ 1:
+                    message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: ExecutionflowLinesDetectedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.ResponseHeader Header = 1; */
+        if (message.Header)
+            ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.ExecutionflowLinesDetectedResponse
+ */
+export const ExecutionflowLinesDetectedResponse = new ExecutionflowLinesDetectedResponse$Type();
 /**
  * @generated ServiceType for protobuf service api.ExecutionflowInputAPI
  */
@@ -7976,5 +8542,7 @@ export const ExecutionflowInputAPI = new ServiceType("api.ExecutionflowInputAPI"
     { name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "An attachment is removed for the Executionflow." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ExecutionflowAttachmentRemovedRequest, O: ExecutionflowAttachmentRemovedResponse },
     { name: "AllocationError", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "An allocation error occured on the Executionflow." }, "api.rscType": "Project", "api.platformReserved": true, "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExecutionflowAllocationErrorRequest, O: ExecutionflowAllocationErrorResponse },
     { name: "ClaimAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "A claim is added for the Executionflow." }, "api.rscType": "Project", "api.roles": "Platform.Project-Claim", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ExecutionflowClaimAddedRequest, O: ExecutionflowClaimAddedResponse },
-    { name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "An executionflow has been deleted. This is called from Reflex Platform Admin service to share the Organisation executionflows." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExecutionflowDeletedRequest, O: ExecutionflowDeletedResponse }
+    { name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "An executionflow has been deleted. This is called from Reflex Platform Admin service to share the Organisation executionflows." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExecutionflowDeletedRequest, O: ExecutionflowDeletedResponse },
+    { name: "LinesAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "Some lines are added for the Executionflow." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ExecutionflowLinesAddedRequest, O: ExecutionflowLinesAddedResponse },
+    { name: "LinesDetected", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "Some lines are added for the Executionflow." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ExecutionflowLinesDetectedRequest, O: ExecutionflowLinesDetectedResponse }
 ], { "api.serviceType": "Api", "api.k8sService": "api-server" });

order.ts

@@ -256,7 +256,7 @@ class OrderPayload$Type extends MessageType<OrderPayload> {
             { no: 9, name: "Carrier", kind: "message", localName: "Carrier", jsonName: "Carrier", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Definition of the order carrier" }, "api.aggSkip": "ExecutionflowDetected" } },
             { no: 16, name: "CarrierService", kind: "scalar", localName: "CarrierService", jsonName: "CarrierService", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Type of carrier service" }, "api.dataRestrictionKey": "Order", "api.kpiItems": { Items: [{ Context: "Order", Group: "order", Queryable: true }] } } },
             { no: 10, name: "RequestedMilestones", kind: "message", localName: "RequestedMilestones", jsonName: "RequestedMilestones", T: () => OrderRequestedMilestones },
-            { no: 11, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OrderLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Lines of the order" }, "api.aggKey": "LineID", "api.aggAppend": "ExecutionflowDetected" } },
+            { no: 11, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OrderLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Lines of the order" }, "api.aggKey": "LineID", "api.aggAppend": "ExecutionflowDetected,LinesAdded,LinesDetected" } },
             { no: 12, name: "EstimatedTimeArrival", kind: "message", localName: "EstimatedTimeArrival", jsonName: "EstimatedTimeArrival", T: () => ETA, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Deprecated from 1.7 : Estimated time of arrival, use OrderETA" } } },
             { no: 13, name: "ActualCompletionDateTime", kind: "message", localName: "ActualCompletionDateTime", jsonName: "ActualCompletionDateTime", T: () => DateTime },
             { no: 14, name: "ExecutionflowSummary", kind: "message", localName: "ExecutionflowSummary", jsonName: "ExecutionflowSummary", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExecutionflowSummary, options: { "api.aggKey": "ExecutionflowID", "api.aggAppend": "ExecutionflowUpdated,ExecutionflowDetected" } },

orderAction.ts

@@ -115,6 +115,42 @@ export interface OrderBuildExecutionflow {
      */
     PreviousPayload?: OrderBuildExecutionflowPayload;
 }
+/**
+ * @generated from protobuf message api.OrderPropagateLinesToExecutionflowPayload
+ */
+export interface OrderPropagateLinesToExecutionflowPayload {
+    /**
+     * Lines of the order
+     *
+     * @generated from protobuf field: repeated api.OrderLine Lines = 11
+     */
+    Lines: OrderLine[];
+}
+/**
+ * @generated from protobuf message api.OrderPropagateLinesToExecutionflow
+ */
+export interface OrderPropagateLinesToExecutionflow {
+    /**
+     * @generated from protobuf field: api.CommandHeader Header = 1
+     */
+    Header?: CommandHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.OrderPropagateLinesToExecutionflowPayload Payload = 3
+     */
+    Payload?: OrderPropagateLinesToExecutionflowPayload;
+    /**
+     * @generated from protobuf field: api.OrderPropagateLinesToExecutionflowPayload EventPayload = 4
+     */
+    EventPayload?: OrderPropagateLinesToExecutionflowPayload;
+    /**
+     * @generated from protobuf field: api.OrderPropagateLinesToExecutionflowPayload PreviousPayload = 5
+     */
+    PreviousPayload?: OrderPropagateLinesToExecutionflowPayload;
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class OrderBuildExecutionflowPayload$Type extends MessageType<OrderBuildExecutionflowPayload> {
     constructor() {
@@ -316,3 +352,124 @@ class OrderBuildExecutionflow$Type extends MessageType<OrderBuildExecutionflow>
  * @generated MessageType for protobuf message api.OrderBuildExecutionflow
  */
 export const OrderBuildExecutionflow = new OrderBuildExecutionflow$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderPropagateLinesToExecutionflowPayload$Type extends MessageType<OrderPropagateLinesToExecutionflowPayload> {
+    constructor() {
+        super("api.OrderPropagateLinesToExecutionflowPayload", [
+            { no: 11, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OrderLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Lines of the order" }, "api.aggKey": "LineID" } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Propagate lines from Order to Executionflow" } }, "api.messageType": "Command", "api.payload": true, "api.action": "PropagateLinesToExecutionflow" });
+    }
+    create(value?: PartialMessage<OrderPropagateLinesToExecutionflowPayload>): OrderPropagateLinesToExecutionflowPayload {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Lines = [];
+        if (value !== undefined)
+            reflectionMergePartial<OrderPropagateLinesToExecutionflowPayload>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderPropagateLinesToExecutionflowPayload): OrderPropagateLinesToExecutionflowPayload {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated api.OrderLine Lines */ 11:
+                    message.Lines.push(OrderLine.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderPropagateLinesToExecutionflowPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated api.OrderLine Lines = 11; */
+        for (let i = 0; i < message.Lines.length; i++)
+            OrderLine.internalBinaryWrite(message.Lines[i], writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderPropagateLinesToExecutionflowPayload
+ */
+export const OrderPropagateLinesToExecutionflowPayload = new OrderPropagateLinesToExecutionflowPayload$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderPropagateLinesToExecutionflow$Type extends MessageType<OrderPropagateLinesToExecutionflow> {
+    constructor() {
+        super("api.OrderPropagateLinesToExecutionflow", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => CommandHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderPropagateLinesToExecutionflowPayload },
+            { no: 4, name: "EventPayload", kind: "message", localName: "EventPayload", jsonName: "EventPayload", T: () => OrderPropagateLinesToExecutionflowPayload },
+            { no: 5, name: "PreviousPayload", kind: "message", localName: "PreviousPayload", jsonName: "PreviousPayload", T: () => OrderPropagateLinesToExecutionflowPayload }
+        ], { "api.messageType": "Command", "api.action": "PropagateLinesToExecutionflow", "api.resultingEvent": "executionflow.LinesDetected", "api.triggerEventFilters": "LinesAdded" });
+    }
+    create(value?: PartialMessage<OrderPropagateLinesToExecutionflow>): OrderPropagateLinesToExecutionflow {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderPropagateLinesToExecutionflow>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderPropagateLinesToExecutionflow): OrderPropagateLinesToExecutionflow {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.CommandHeader Header */ 1:
+                    message.Header = CommandHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.OrderPropagateLinesToExecutionflowPayload Payload */ 3:
+                    message.Payload = OrderPropagateLinesToExecutionflowPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                case /* api.OrderPropagateLinesToExecutionflowPayload EventPayload */ 4:
+                    message.EventPayload = OrderPropagateLinesToExecutionflowPayload.internalBinaryRead(reader, reader.uint32(), options, message.EventPayload);
+                    break;
+                case /* api.OrderPropagateLinesToExecutionflowPayload PreviousPayload */ 5:
+                    message.PreviousPayload = OrderPropagateLinesToExecutionflowPayload.internalBinaryRead(reader, reader.uint32(), options, message.PreviousPayload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderPropagateLinesToExecutionflow, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.CommandHeader Header = 1; */
+        if (message.Header)
+            CommandHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.OrderPropagateLinesToExecutionflowPayload Payload = 3; */
+        if (message.Payload)
+            OrderPropagateLinesToExecutionflowPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* api.OrderPropagateLinesToExecutionflowPayload EventPayload = 4; */
+        if (message.EventPayload)
+            OrderPropagateLinesToExecutionflowPayload.internalBinaryWrite(message.EventPayload, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* api.OrderPropagateLinesToExecutionflowPayload PreviousPayload = 5; */
+        if (message.PreviousPayload)
+            OrderPropagateLinesToExecutionflowPayload.internalBinaryWrite(message.PreviousPayload, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderPropagateLinesToExecutionflow
+ */
+export const OrderPropagateLinesToExecutionflow = new OrderPropagateLinesToExecutionflow$Type();

orderInput.client.ts

@@ -4,6 +4,10 @@
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
 import { OrderInputAPI } from "./orderInput";
+import type { OrderLinesDetectedResponse } from "./orderInput";
+import type { OrderLinesDetectedRequest } from "./orderInput";
+import type { OrderLinesAddedResponse } from "./orderInput";
+import type { OrderLinesAddedRequest } from "./orderInput";
 import type { OrderDeletedResponse } from "./orderInput";
 import type { OrderDeletedRequest } from "./orderInput";
 import type { OrderClaimAddedResponse } from "./orderInput";
@@ -110,6 +114,14 @@ export interface IOrderInputAPIClient {
      * @generated from protobuf rpc: Deleted
      */
     deleted(input: OrderDeletedRequest, options?: RpcOptions): UnaryCall<OrderDeletedRequest, OrderDeletedResponse>;
+    /**
+     * @generated from protobuf rpc: LinesAdded
+     */
+    linesAdded(input: OrderLinesAddedRequest, options?: RpcOptions): UnaryCall<OrderLinesAddedRequest, OrderLinesAddedResponse>;
+    /**
+     * @generated from protobuf rpc: LinesDetected
+     */
+    linesDetected(input: OrderLinesDetectedRequest, options?: RpcOptions): UnaryCall<OrderLinesDetectedRequest, OrderLinesDetectedResponse>;
 }
 /**
  *
@@ -235,4 +247,18 @@ export class OrderInputAPIClient implements IOrderInputAPIClient, ServiceInfo {
         const method = this.methods[15], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderDeletedRequest, OrderDeletedResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: LinesAdded
+     */
+    linesAdded(input: OrderLinesAddedRequest, options?: RpcOptions): UnaryCall<OrderLinesAddedRequest, OrderLinesAddedResponse> {
+        const method = this.methods[16], opt = this._transport.mergeOptions(options);
+        return stackIntercept<OrderLinesAddedRequest, OrderLinesAddedResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: LinesDetected
+     */
+    linesDetected(input: OrderLinesDetectedRequest, options?: RpcOptions): UnaryCall<OrderLinesDetectedRequest, OrderLinesDetectedResponse> {
+        const method = this.methods[17], opt = this._transport.mergeOptions(options);
+        return stackIntercept<OrderLinesDetectedRequest, OrderLinesDetectedResponse>("unary", this._transport, method, opt, input);
+    }
 }

orderInput.ts

@@ -1150,6 +1150,132 @@ export interface OrderDeletedResponse {
      */
     ID?: EntityID;
 }
+/**
+ * Event Payload
+ *
+ * @generated from protobuf message api.OrderLinesAddedPayload
+ */
+export interface OrderLinesAddedPayload {
+    /**
+     * @generated from protobuf field: repeated api.OrderLine Lines = 1
+     */
+    Lines: OrderLine[];
+}
+/**
+ * Event message
+ *
+ * @generated from protobuf message api.OrderLinesAddedEvent
+ */
+export interface OrderLinesAddedEvent {
+    /**
+     * @generated from protobuf field: api.EventHeader Header = 1
+     */
+    Header?: EventHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.OrderLinesAddedPayload Payload = 3
+     */
+    Payload?: OrderLinesAddedPayload;
+}
+/**
+ * API Request
+ *
+ * @generated from protobuf message api.OrderLinesAddedRequest
+ */
+export interface OrderLinesAddedRequest {
+    /**
+     * @generated from protobuf field: api.RequestProjectHeader Header = 1
+     */
+    Header?: RequestProjectHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.OrderLinesAddedPayload Payload = 3
+     */
+    Payload?: OrderLinesAddedPayload;
+}
+/**
+ * API Response
+ *
+ * @generated from protobuf message api.OrderLinesAddedResponse
+ */
+export interface OrderLinesAddedResponse {
+    /**
+     * @generated from protobuf field: api.ResponseHeader Header = 1
+     */
+    Header?: ResponseHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+}
+/**
+ * @generated from protobuf message api.OrderLinesDetectedPayload
+ */
+export interface OrderLinesDetectedPayload {
+    /**
+     * @generated from protobuf field: repeated api.OrderLine Lines = 1
+     */
+    Lines: OrderLine[];
+}
+/**
+ * Event message
+ *
+ * @generated from protobuf message api.OrderLinesDetectedEvent
+ */
+export interface OrderLinesDetectedEvent {
+    /**
+     * @generated from protobuf field: api.EventHeader Header = 1
+     */
+    Header?: EventHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.OrderLinesDetectedPayload Payload = 3
+     */
+    Payload?: OrderLinesDetectedPayload;
+}
+/**
+ * API Request
+ *
+ * @generated from protobuf message api.OrderLinesDetectedRequest
+ */
+export interface OrderLinesDetectedRequest {
+    /**
+     * @generated from protobuf field: api.RequestProjectHeader Header = 1
+     */
+    Header?: RequestProjectHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+    /**
+     * @generated from protobuf field: api.OrderLinesDetectedPayload Payload = 3
+     */
+    Payload?: OrderLinesDetectedPayload;
+}
+/**
+ * API Response
+ *
+ * @generated from protobuf message api.OrderLinesDetectedResponse
+ */
+export interface OrderLinesDetectedResponse {
+    /**
+     * @generated from protobuf field: api.ResponseHeader Header = 1
+     */
+    Header?: ResponseHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+}
 // @generated message type with reflection information, may provide speed optimized methods
 class OrderCreatedPayload$Type extends MessageType<OrderCreatedPayload> {
     constructor() {
@@ -4777,6 +4903,446 @@ class OrderDeletedResponse$Type extends MessageType<OrderDeletedResponse> {
  * @generated MessageType for protobuf message api.OrderDeletedResponse
  */
 export const OrderDeletedResponse = new OrderDeletedResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesAddedPayload$Type extends MessageType<OrderLinesAddedPayload> {
+    constructor() {
+        super("api.OrderLinesAddedPayload", [
+            { no: 1, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OrderLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Lines of the order" }, "api.aggKey": "LineID" } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<OrderLinesAddedPayload>): OrderLinesAddedPayload {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Lines = [];
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesAddedPayload>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesAddedPayload): OrderLinesAddedPayload {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated api.OrderLine Lines */ 1:
+                    message.Lines.push(OrderLine.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesAddedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated api.OrderLine Lines = 1; */
+        for (let i = 0; i < message.Lines.length; i++)
+            OrderLine.internalBinaryWrite(message.Lines[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesAddedPayload
+ */
+export const OrderLinesAddedPayload = new OrderLinesAddedPayload$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesAddedEvent$Type extends MessageType<OrderLinesAddedEvent> {
+    constructor() {
+        super("api.OrderLinesAddedEvent", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderLinesAddedPayload }
+        ], { "api.messageType": "Event", "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<OrderLinesAddedEvent>): OrderLinesAddedEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesAddedEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesAddedEvent): OrderLinesAddedEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.EventHeader Header */ 1:
+                    message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.OrderLinesAddedPayload Payload */ 3:
+                    message.Payload = OrderLinesAddedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.EventHeader Header = 1; */
+        if (message.Header)
+            EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.OrderLinesAddedPayload Payload = 3; */
+        if (message.Payload)
+            OrderLinesAddedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesAddedEvent
+ */
+export const OrderLinesAddedEvent = new OrderLinesAddedEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesAddedRequest$Type extends MessageType<OrderLinesAddedRequest> {
+    constructor() {
+        super("api.OrderLinesAddedRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderLinesAddedPayload }
+        ], { "api.messageType": "Request", "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<OrderLinesAddedRequest>): OrderLinesAddedRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesAddedRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesAddedRequest): OrderLinesAddedRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestProjectHeader Header */ 1:
+                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.OrderLinesAddedPayload Payload */ 3:
+                    message.Payload = OrderLinesAddedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesAddedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestProjectHeader Header = 1; */
+        if (message.Header)
+            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.OrderLinesAddedPayload Payload = 3; */
+        if (message.Payload)
+            OrderLinesAddedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesAddedRequest
+ */
+export const OrderLinesAddedRequest = new OrderLinesAddedRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesAddedResponse$Type extends MessageType<OrderLinesAddedResponse> {
+    constructor() {
+        super("api.OrderLinesAddedResponse", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
+        ], { "api.messageType": "Response", "api.inputEvent": "LinesAdded" });
+    }
+    create(value?: PartialMessage<OrderLinesAddedResponse>): OrderLinesAddedResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesAddedResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesAddedResponse): OrderLinesAddedResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.ResponseHeader Header */ 1:
+                    message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesAddedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.ResponseHeader Header = 1; */
+        if (message.Header)
+            ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesAddedResponse
+ */
+export const OrderLinesAddedResponse = new OrderLinesAddedResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesDetectedPayload$Type extends MessageType<OrderLinesDetectedPayload> {
+    constructor() {
+        super("api.OrderLinesDetectedPayload", [
+            { no: 1, name: "Lines", kind: "message", localName: "Lines", jsonName: "Lines", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OrderLine, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Lines of the order" }, "api.aggKey": "LineID" } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<OrderLinesDetectedPayload>): OrderLinesDetectedPayload {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.Lines = [];
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesDetectedPayload>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesDetectedPayload): OrderLinesDetectedPayload {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated api.OrderLine Lines */ 1:
+                    message.Lines.push(OrderLine.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesDetectedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated api.OrderLine Lines = 1; */
+        for (let i = 0; i < message.Lines.length; i++)
+            OrderLine.internalBinaryWrite(message.Lines[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesDetectedPayload
+ */
+export const OrderLinesDetectedPayload = new OrderLinesDetectedPayload$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesDetectedEvent$Type extends MessageType<OrderLinesDetectedEvent> {
+    constructor() {
+        super("api.OrderLinesDetectedEvent", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderLinesDetectedPayload }
+        ], { "api.messageType": "Event", "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<OrderLinesDetectedEvent>): OrderLinesDetectedEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesDetectedEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesDetectedEvent): OrderLinesDetectedEvent {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.EventHeader Header */ 1:
+                    message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.OrderLinesDetectedPayload Payload */ 3:
+                    message.Payload = OrderLinesDetectedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesDetectedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.EventHeader Header = 1; */
+        if (message.Header)
+            EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.OrderLinesDetectedPayload Payload = 3; */
+        if (message.Payload)
+            OrderLinesDetectedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesDetectedEvent
+ */
+export const OrderLinesDetectedEvent = new OrderLinesDetectedEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesDetectedRequest$Type extends MessageType<OrderLinesDetectedRequest> {
+    constructor() {
+        super("api.OrderLinesDetectedRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderLinesDetectedPayload }
+        ], { "api.messageType": "Request", "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<OrderLinesDetectedRequest>): OrderLinesDetectedRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesDetectedRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesDetectedRequest): OrderLinesDetectedRequest {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.RequestProjectHeader Header */ 1:
+                    message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                case /* api.OrderLinesDetectedPayload Payload */ 3:
+                    message.Payload = OrderLinesDetectedPayload.internalBinaryRead(reader, reader.uint32(), options, message.Payload);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesDetectedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.RequestProjectHeader Header = 1; */
+        if (message.Header)
+            RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* api.OrderLinesDetectedPayload Payload = 3; */
+        if (message.Payload)
+            OrderLinesDetectedPayload.internalBinaryWrite(message.Payload, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesDetectedRequest
+ */
+export const OrderLinesDetectedRequest = new OrderLinesDetectedRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderLinesDetectedResponse$Type extends MessageType<OrderLinesDetectedResponse> {
+    constructor() {
+        super("api.OrderLinesDetectedResponse", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
+        ], { "api.messageType": "Response", "api.inputEvent": "LinesDetected" });
+    }
+    create(value?: PartialMessage<OrderLinesDetectedResponse>): OrderLinesDetectedResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderLinesDetectedResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderLinesDetectedResponse): OrderLinesDetectedResponse {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* api.ResponseHeader Header */ 1:
+                    message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
+                    break;
+                case /* api.EntityID ID */ 2:
+                    message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: OrderLinesDetectedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* api.ResponseHeader Header = 1; */
+        if (message.Header)
+            ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* api.EntityID ID = 2; */
+        if (message.ID)
+            EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderLinesDetectedResponse
+ */
+export const OrderLinesDetectedResponse = new OrderLinesDetectedResponse$Type();
 /**
  * @generated ServiceType for protobuf service api.OrderInputAPI
  */
@@ -4796,5 +5362,7 @@ export const OrderInputAPI = new ServiceType("api.OrderInputAPI", [
     { name: "AttachmentAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An attachment is added for the Order." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderAttachmentAddedRequest, O: OrderAttachmentAddedResponse },
     { name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An attachment is removed for the Order." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderAttachmentRemovedRequest, O: OrderAttachmentRemovedResponse },
     { name: "ClaimAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "A claim is added for the Order." }, "api.rscType": "Project", "api.roles": "Platform.Project-Claim", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderClaimAddedRequest, O: OrderClaimAddedResponse },
-    { name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An Order has been deleted. This is called from Reflex Platform Admin service to share the Organisation Orders." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderDeletedRequest, O: OrderDeletedResponse }
+    { name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An Order has been deleted. This is called from Reflex Platform Admin service to share the Organisation Orders." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderDeletedRequest, O: OrderDeletedResponse },
+    { name: "LinesAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "Some lines are added for the Order." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderLinesAddedRequest, O: OrderLinesAddedResponse },
+    { name: "LinesDetected", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "Some lines are propagated from executionflow to the Order." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderLinesDetectedRequest, O: OrderLinesDetectedResponse }
 ], { "api.serviceType": "Api", "api.k8sService": "api-server" });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reflex-platform/npm-core-sdk",
-  "version": "1.11.0-SNAPSHOT-250603131843",
+  "version": "1.11.0-SNAPSHOT-250605090424",
   "description": "npm libs from core model proto files",
   "homepage": "",
   "main": "index.ts",