Latest generation

order.ts

@@ -160,6 +160,10 @@ export interface OrderPayload {
      * @generated from protobuf field: bool AppointmentBookingDisabled = 27
      */
     AppointmentBookingDisabled: boolean;
+    /**
+     * @generated from protobuf field: bool AnticipatedClosed = 28
+     */
+    AnticipatedClosed: boolean;
 }
 /**
  * Order entity
@@ -289,7 +293,8 @@ class OrderPayload$Type extends MessageType<OrderPayload> {
             { no: 24, name: "Anticipated", kind: "scalar", localName: "Anticipated", jsonName: "Anticipated", T: 8 /*ScalarType.BOOL*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Anticipated orders are not automatically associated to an executionflow" } } },
             { no: 25, name: "Appointments", kind: "message", localName: "Appointments", jsonName: "Appointments", repeat: 2 /*RepeatType.UNPACKED*/, T: () => AppointmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "List of appointments attached to the order" }, "api.aggSkip": "AppointmentUpdated" } },
             { no: 26, name: "RemovedAppointments", kind: "message", localName: "RemovedAppointments", jsonName: "RemovedAppointments", repeat: 2 /*RepeatType.UNPACKED*/, T: () => AppointmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { readOnly: true }, "api.aggSkip": "AppointmentUpdated", "api.indexationSkip": true } },
-            { no: 27, name: "AppointmentBookingDisabled", kind: "scalar", localName: "AppointmentBookingDisabled", jsonName: "AppointmentBookingDisabled", T: 8 /*ScalarType.BOOL*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "If true, appointment booking is disabled for this order" } } }
+            { no: 27, name: "AppointmentBookingDisabled", kind: "scalar", localName: "AppointmentBookingDisabled", jsonName: "AppointmentBookingDisabled", T: 8 /*ScalarType.BOOL*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "If true, appointment booking is disabled for this order" } } },
+            { no: 28, name: "AnticipatedClosed", kind: "scalar", localName: "AnticipatedClosed", jsonName: "AnticipatedClosed", T: 8 /*ScalarType.BOOL*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "If true, anticipated order is closed" } } }
         ]);
     }
     create(value?: PartialMessage<OrderPayload>): OrderPayload {
@@ -308,6 +313,7 @@ class OrderPayload$Type extends MessageType<OrderPayload> {
         message.Appointments = [];
         message.RemovedAppointments = [];
         message.AppointmentBookingDisabled = false;
+        message.AnticipatedClosed = false;
         if (value !== undefined)
             reflectionMergePartial<OrderPayload>(this, message, value);
         return message;
@@ -395,6 +401,9 @@ class OrderPayload$Type extends MessageType<OrderPayload> {
                 case /* bool AppointmentBookingDisabled */ 27:
                     message.AppointmentBookingDisabled = reader.bool();
                     break;
+                case /* bool AnticipatedClosed */ 28:
+                    message.AnticipatedClosed = reader.bool();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -485,6 +494,9 @@ class OrderPayload$Type extends MessageType<OrderPayload> {
         /* bool AppointmentBookingDisabled = 27; */
         if (message.AppointmentBookingDisabled !== false)
             writer.tag(27, WireType.Varint).bool(message.AppointmentBookingDisabled);
+        /* bool AnticipatedClosed = 28; */
+        if (message.AnticipatedClosed !== false)
+            writer.tag(28, WireType.Varint).bool(message.AnticipatedClosed);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

orderInput.client.ts

@@ -48,6 +48,8 @@ import type { OrderMetaDataUpdatedResponse } from "./orderInput";
 import type { OrderMetaDataUpdatedRequest } from "./orderInput";
 import type { OrderExecutionflowUpdatedResponse } from "./orderInput";
 import type { OrderExecutionflowUpdatedRequest } from "./orderInput";
+import type { OrderAnticipatedClosedResponse } from "./orderInput";
+import type { OrderAnticipatedClosedRequest } from "./orderInput";
 import type { OrderCompletedResponse } from "./orderInput";
 import type { OrderCompletedRequest } from "./orderInput";
 import type { OrderExecutionflowETAUpdatedResponse } from "./orderInput";
@@ -118,6 +120,10 @@ export interface IOrderInputAPIClient {
      * @generated from protobuf rpc: Completed
      */
     completed(input: OrderCompletedRequest, options?: RpcOptions): UnaryCall<OrderCompletedRequest, OrderCompletedResponse>;
+    /**
+     * @generated from protobuf rpc: AnticipatedClosed
+     */
+    anticipatedClosed(input: OrderAnticipatedClosedRequest, options?: RpcOptions): UnaryCall<OrderAnticipatedClosedRequest, OrderAnticipatedClosedResponse>;
     /**
      * @generated from protobuf rpc: ExecutionflowUpdated
      */
@@ -289,158 +295,165 @@ export class OrderInputAPIClient implements IOrderInputAPIClient, ServiceInfo {
         const method = this.methods[9], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderCompletedRequest, OrderCompletedResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: AnticipatedClosed
+     */
+    anticipatedClosed(input: OrderAnticipatedClosedRequest, options?: RpcOptions): UnaryCall<OrderAnticipatedClosedRequest, OrderAnticipatedClosedResponse> {
+        const method = this.methods[10], opt = this._transport.mergeOptions(options);
+        return stackIntercept<OrderAnticipatedClosedRequest, OrderAnticipatedClosedResponse>("unary", this._transport, method, opt, input);
+    }
     /**
      * @generated from protobuf rpc: ExecutionflowUpdated
      */
     executionflowUpdated(input: OrderExecutionflowUpdatedRequest, options?: RpcOptions): UnaryCall<OrderExecutionflowUpdatedRequest, OrderExecutionflowUpdatedResponse> {
-        const method = this.methods[10], opt = this._transport.mergeOptions(options);
+        const method = this.methods[11], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderExecutionflowUpdatedRequest, OrderExecutionflowUpdatedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: MetaDataUpdated
      */
     metaDataUpdated(input: OrderMetaDataUpdatedRequest, options?: RpcOptions): UnaryCall<OrderMetaDataUpdatedRequest, OrderMetaDataUpdatedResponse> {
-        const method = this.methods[11], opt = this._transport.mergeOptions(options);
+        const method = this.methods[12], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderMetaDataUpdatedRequest, OrderMetaDataUpdatedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: CarrierUpdated
      */
     carrierUpdated(input: OrderCarrierUpdatedRequest, options?: RpcOptions): UnaryCall<OrderCarrierUpdatedRequest, OrderCarrierUpdatedResponse> {
-        const method = this.methods[12], opt = this._transport.mergeOptions(options);
+        const method = this.methods[13], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderCarrierUpdatedRequest, OrderCarrierUpdatedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: AttachmentAdded
      */
     attachmentAdded(input: OrderAttachmentAddedRequest, options?: RpcOptions): UnaryCall<OrderAttachmentAddedRequest, OrderAttachmentAddedResponse> {
-        const method = this.methods[13], opt = this._transport.mergeOptions(options);
+        const method = this.methods[14], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderAttachmentAddedRequest, OrderAttachmentAddedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: AttachmentRemoved
      */
     attachmentRemoved(input: OrderAttachmentRemovedRequest, options?: RpcOptions): UnaryCall<OrderAttachmentRemovedRequest, OrderAttachmentRemovedResponse> {
-        const method = this.methods[14], opt = this._transport.mergeOptions(options);
+        const method = this.methods[15], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderAttachmentRemovedRequest, OrderAttachmentRemovedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: ClaimAdded
      */
     claimAdded(input: OrderClaimAddedRequest, options?: RpcOptions): UnaryCall<OrderClaimAddedRequest, OrderClaimAddedResponse> {
-        const method = this.methods[15], opt = this._transport.mergeOptions(options);
+        const method = this.methods[16], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderClaimAddedRequest, OrderClaimAddedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: Deleted
      */
     deleted(input: OrderDeletedRequest, options?: RpcOptions): UnaryCall<OrderDeletedRequest, OrderDeletedResponse> {
-        const method = this.methods[16], opt = this._transport.mergeOptions(options);
+        const method = this.methods[17], 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[17], opt = this._transport.mergeOptions(options);
+        const method = this.methods[18], 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[18], opt = this._transport.mergeOptions(options);
+        const method = this.methods[19], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderLinesDetectedRequest, OrderLinesDetectedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: Sanitised
      */
     sanitised(input: OrderSanitisedRequest, options?: RpcOptions): UnaryCall<OrderSanitisedRequest, OrderSanitisedResponse> {
-        const method = this.methods[19], opt = this._transport.mergeOptions(options);
+        const method = this.methods[20], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderSanitisedRequest, OrderSanitisedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: CustomFieldsUpdated
      */
     customFieldsUpdated(input: OrderCustomFieldsUpdatedRequest, options?: RpcOptions): UnaryCall<OrderCustomFieldsUpdatedRequest, OrderCustomFieldsUpdatedResponse> {
-        const method = this.methods[20], opt = this._transport.mergeOptions(options);
+        const method = this.methods[21], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderCustomFieldsUpdatedRequest, OrderCustomFieldsUpdatedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: PreparationExpected
      */
     preparationExpected(input: OrderPreparationExpectedRequest, options?: RpcOptions): UnaryCall<OrderPreparationExpectedRequest, OrderPreparationExpectedResponse> {
-        const method = this.methods[21], opt = this._transport.mergeOptions(options);
+        const method = this.methods[22], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderPreparationExpectedRequest, OrderPreparationExpectedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: PreparationStarted
      */
     preparationStarted(input: OrderPreparationStartedRequest, options?: RpcOptions): UnaryCall<OrderPreparationStartedRequest, OrderPreparationStartedResponse> {
-        const method = this.methods[22], opt = this._transport.mergeOptions(options);
+        const method = this.methods[23], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderPreparationStartedRequest, OrderPreparationStartedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: PreparationCompleted
      */
     preparationCompleted(input: OrderPreparationCompletedRequest, options?: RpcOptions): UnaryCall<OrderPreparationCompletedRequest, OrderPreparationCompletedResponse> {
-        const method = this.methods[23], opt = this._transport.mergeOptions(options);
+        const method = this.methods[24], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderPreparationCompletedRequest, OrderPreparationCompletedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: TransportExpected
      */
     transportExpected(input: OrderTransportExpectedRequest, options?: RpcOptions): UnaryCall<OrderTransportExpectedRequest, OrderTransportExpectedResponse> {
-        const method = this.methods[24], opt = this._transport.mergeOptions(options);
+        const method = this.methods[25], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderTransportExpectedRequest, OrderTransportExpectedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: TransportStarted
      */
     transportStarted(input: OrderTransportStartedRequest, options?: RpcOptions): UnaryCall<OrderTransportStartedRequest, OrderTransportStartedResponse> {
-        const method = this.methods[25], opt = this._transport.mergeOptions(options);
+        const method = this.methods[26], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderTransportStartedRequest, OrderTransportStartedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: TransportCompleted
      */
     transportCompleted(input: OrderTransportCompletedRequest, options?: RpcOptions): UnaryCall<OrderTransportCompletedRequest, OrderTransportCompletedResponse> {
-        const method = this.methods[26], opt = this._transport.mergeOptions(options);
+        const method = this.methods[27], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderTransportCompletedRequest, OrderTransportCompletedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: ReceiptExpected
      */
     receiptExpected(input: OrderReceiptExpectedRequest, options?: RpcOptions): UnaryCall<OrderReceiptExpectedRequest, OrderReceiptExpectedResponse> {
-        const method = this.methods[27], opt = this._transport.mergeOptions(options);
+        const method = this.methods[28], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderReceiptExpectedRequest, OrderReceiptExpectedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: ReceiptStarted
      */
     receiptStarted(input: OrderReceiptStartedRequest, options?: RpcOptions): UnaryCall<OrderReceiptStartedRequest, OrderReceiptStartedResponse> {
-        const method = this.methods[28], opt = this._transport.mergeOptions(options);
+        const method = this.methods[29], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderReceiptStartedRequest, OrderReceiptStartedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: ReceiptCompleted
      */
     receiptCompleted(input: OrderReceiptCompletedRequest, options?: RpcOptions): UnaryCall<OrderReceiptCompletedRequest, OrderReceiptCompletedResponse> {
-        const method = this.methods[29], opt = this._transport.mergeOptions(options);
+        const method = this.methods[30], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderReceiptCompletedRequest, OrderReceiptCompletedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: AppointmentUpdated
      */
     appointmentUpdated(input: OrderAppointmentUpdatedRequest, options?: RpcOptions): UnaryCall<OrderAppointmentUpdatedRequest, OrderAppointmentUpdatedResponse> {
-        const method = this.methods[30], opt = this._transport.mergeOptions(options);
+        const method = this.methods[31], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderAppointmentUpdatedRequest, OrderAppointmentUpdatedResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: AppointmentBookingDisabled
      */
     appointmentBookingDisabled(input: OrderAppointmentBookingDisabledRequest, options?: RpcOptions): UnaryCall<OrderAppointmentBookingDisabledRequest, OrderAppointmentBookingDisabledResponse> {
-        const method = this.methods[31], opt = this._transport.mergeOptions(options);
+        const method = this.methods[32], opt = this._transport.mergeOptions(options);
         return stackIntercept<OrderAppointmentBookingDisabledRequest, OrderAppointmentBookingDisabledResponse>("unary", this._transport, method, opt, input);
     }
 }

orderInput.ts

@@ -775,6 +775,60 @@ export interface OrderCompletedResponse {
      */
     ID?: EntityID;
 }
+// OrderAnticipatedClosed
+
+/**
+ * @generated from protobuf message api.OrderAnticipatedClosedPayload
+ */
+export interface OrderAnticipatedClosedPayload {
+}
+/**
+ * @generated from protobuf message api.OrderAnticipatedClosedEvent
+ */
+export interface OrderAnticipatedClosedEvent {
+    /**
+     * @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.OrderAnticipatedClosedPayload Payload = 3
+     */
+    Payload?: OrderAnticipatedClosedPayload;
+}
+/**
+ * @generated from protobuf message api.OrderAnticipatedClosedRequest
+ */
+export interface OrderAnticipatedClosedRequest {
+    /**
+     * @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.OrderAnticipatedClosedPayload Payload = 3
+     */
+    Payload?: OrderAnticipatedClosedPayload;
+}
+/**
+ * @generated from protobuf message api.OrderAnticipatedClosedResponse
+ */
+export interface OrderAnticipatedClosedResponse {
+    /**
+     * @generated from protobuf field: api.ResponseHeader Header = 1
+     */
+    Header?: ResponseHeader;
+    /**
+     * @generated from protobuf field: api.EntityID ID = 2
+     */
+    ID?: EntityID;
+}
 // 
 // ExecutionflowUpdated
 // - Inform the order about the Executionflow instance status.
@@ -4443,6 +4497,217 @@ class OrderCompletedResponse$Type extends MessageType<OrderCompletedResponse> {
  */
 export const OrderCompletedResponse = new OrderCompletedResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class OrderAnticipatedClosedPayload$Type extends MessageType<OrderAnticipatedClosedPayload> {
+    constructor() {
+        super("api.OrderAnticipatedClosedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AnticipatedClosed" });
+    }
+    create(value?: PartialMessage<OrderAnticipatedClosedPayload>): OrderAnticipatedClosedPayload {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderAnticipatedClosedPayload>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderAnticipatedClosedPayload): OrderAnticipatedClosedPayload {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                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: OrderAnticipatedClosedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message api.OrderAnticipatedClosedPayload
+ */
+export const OrderAnticipatedClosedPayload = new OrderAnticipatedClosedPayload$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderAnticipatedClosedEvent$Type extends MessageType<OrderAnticipatedClosedEvent> {
+    constructor() {
+        super("api.OrderAnticipatedClosedEvent", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "n1validate.rules": { message: { required: true } } } },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "n1validate.rules": { message: { required: true } } } },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderAnticipatedClosedPayload, options: { "n1validate.rules": { message: { required: true } } } }
+        ], { "api.messageType": "Event", "api.inputEvent": "AnticipatedClosed", "api.preAggMethods": "closeAnticipated" });
+    }
+    create(value?: PartialMessage<OrderAnticipatedClosedEvent>): OrderAnticipatedClosedEvent {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderAnticipatedClosedEvent>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderAnticipatedClosedEvent): OrderAnticipatedClosedEvent {
+        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.OrderAnticipatedClosedPayload Payload */ 3:
+                    message.Payload = OrderAnticipatedClosedPayload.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: OrderAnticipatedClosedEvent, 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.OrderAnticipatedClosedPayload Payload = 3; */
+        if (message.Payload)
+            OrderAnticipatedClosedPayload.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.OrderAnticipatedClosedEvent
+ */
+export const OrderAnticipatedClosedEvent = new OrderAnticipatedClosedEvent$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderAnticipatedClosedRequest$Type extends MessageType<OrderAnticipatedClosedRequest> {
+    constructor() {
+        super("api.OrderAnticipatedClosedRequest", [
+            { no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "n1validate.rules": { message: { required: true } } } },
+            { no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "n1validate.rules": { message: { required: true } } } },
+            { no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderAnticipatedClosedPayload, options: { "n1validate.rules": { message: { required: true } } } }
+        ], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "AnticipatedClosed" });
+    }
+    create(value?: PartialMessage<OrderAnticipatedClosedRequest>): OrderAnticipatedClosedRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderAnticipatedClosedRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderAnticipatedClosedRequest): OrderAnticipatedClosedRequest {
+        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.OrderAnticipatedClosedPayload Payload */ 3:
+                    message.Payload = OrderAnticipatedClosedPayload.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: OrderAnticipatedClosedRequest, 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.OrderAnticipatedClosedPayload Payload = 3; */
+        if (message.Payload)
+            OrderAnticipatedClosedPayload.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.OrderAnticipatedClosedRequest
+ */
+export const OrderAnticipatedClosedRequest = new OrderAnticipatedClosedRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OrderAnticipatedClosedResponse$Type extends MessageType<OrderAnticipatedClosedResponse> {
+    constructor() {
+        super("api.OrderAnticipatedClosedResponse", [
+            { 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": "AnticipatedClosed" });
+    }
+    create(value?: PartialMessage<OrderAnticipatedClosedResponse>): OrderAnticipatedClosedResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<OrderAnticipatedClosedResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderAnticipatedClosedResponse): OrderAnticipatedClosedResponse {
+        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: OrderAnticipatedClosedResponse, 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.OrderAnticipatedClosedResponse
+ */
+export const OrderAnticipatedClosedResponse = new OrderAnticipatedClosedResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class OrderExecutionflowUpdatedPayload$Type extends MessageType<OrderExecutionflowUpdatedPayload> {
     constructor() {
         super("api.OrderExecutionflowUpdatedPayload", [
@@ -9284,6 +9549,7 @@ export const OrderInputAPI = new ServiceType("api.OrderInputAPI", [
     { name: "RequestedDeliveryDateDefined", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "A requested delivery date has been defined on an Order. This is typically called from an ERP." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.tags": "PROJECT_ACTIVITY", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderRequestedDeliveryDateDefinedRequest, O: OrderRequestedDeliveryDateDefinedResponse },
     { name: "ExecutionflowETAUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "A ETA has been updated on an Executionflow attached to this order. This is internal call." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "api.tags": "PROJECT_ACTIVITY", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderExecutionflowETAUpdatedRequest, O: OrderExecutionflowETAUpdatedResponse },
     { name: "Completed", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An Order has been completed. This is typically called from an ERP." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.tags": "PROJECT_ACTIVITY", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderCompletedRequest, O: OrderCompletedResponse },
+    { name: "AnticipatedClosed", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An anticipated Order has been closed." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.tags": "PROJECT_ACTIVITY", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderAnticipatedClosedRequest, O: OrderAnticipatedClosedResponse },
     { name: "ExecutionflowUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An executionflow status has been reported to an Order. This is called internally." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "api.tags": "PROJECT_ACTIVITY", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderExecutionflowUpdatedRequest, O: OrderExecutionflowUpdatedResponse },
     { name: "MetaDataUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "Some metadata have been updated on an Order. This is typically called from OMS or ERP." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.tags": "PROJECT_ACTIVITY", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderMetaDataUpdatedRequest, O: OrderMetaDataUpdatedResponse },
     { name: "CarrierUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "The carrier and/or carrier service has been updated for the Order. This is typically called from OMS or ERP." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.tags": "PROJECT_ACTIVITY", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderCarrierUpdatedRequest, O: OrderCarrierUpdatedResponse },

package.json

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