From 5c2bd89f122475f11bb1e87ecdda12a55e12687c Mon Sep 17 00:00:00 2001 From: ci core model Date: Thu, 18 Jun 2026 06:59:27 +0000 Subject: [PATCH] Latest generation --- order.ts | 14 ++- orderInput.client.ts | 57 ++++++---- orderInput.ts | 266 +++++++++++++++++++++++++++++++++++++++++++ package.json | 2 +- 4 files changed, 315 insertions(+), 24 deletions(-) diff --git a/order.ts b/order.ts index a5e7f82..1811965 100644 --- a/order.ts +++ b/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 { { 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 { @@ -308,6 +313,7 @@ class OrderPayload$Type extends MessageType { message.Appointments = []; message.RemovedAppointments = []; message.AppointmentBookingDisabled = false; + message.AnticipatedClosed = false; if (value !== undefined) reflectionMergePartial(this, message, value); return message; @@ -395,6 +401,9 @@ class OrderPayload$Type extends MessageType { 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 { /* 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); diff --git a/orderInput.client.ts b/orderInput.client.ts index 942b33e..86a9dba 100644 --- a/orderInput.client.ts +++ b/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; + /** + * @generated from protobuf rpc: AnticipatedClosed + */ + anticipatedClosed(input: OrderAnticipatedClosedRequest, options?: RpcOptions): UnaryCall; /** * @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("unary", this._transport, method, opt, input); } + /** + * @generated from protobuf rpc: AnticipatedClosed + */ + anticipatedClosed(input: OrderAnticipatedClosedRequest, options?: RpcOptions): UnaryCall { + const method = this.methods[10], opt = this._transport.mergeOptions(options); + return stackIntercept("unary", this._transport, method, opt, input); + } /** * @generated from protobuf rpc: ExecutionflowUpdated */ executionflowUpdated(input: OrderExecutionflowUpdatedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[10], opt = this._transport.mergeOptions(options); + const method = this.methods[11], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: MetaDataUpdated */ metaDataUpdated(input: OrderMetaDataUpdatedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[11], opt = this._transport.mergeOptions(options); + const method = this.methods[12], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: CarrierUpdated */ carrierUpdated(input: OrderCarrierUpdatedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[12], opt = this._transport.mergeOptions(options); + const method = this.methods[13], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: AttachmentAdded */ attachmentAdded(input: OrderAttachmentAddedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[13], opt = this._transport.mergeOptions(options); + const method = this.methods[14], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: AttachmentRemoved */ attachmentRemoved(input: OrderAttachmentRemovedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[14], opt = this._transport.mergeOptions(options); + const method = this.methods[15], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: ClaimAdded */ claimAdded(input: OrderClaimAddedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[15], opt = this._transport.mergeOptions(options); + const method = this.methods[16], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: Deleted */ deleted(input: OrderDeletedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[16], opt = this._transport.mergeOptions(options); + const method = this.methods[17], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: LinesAdded */ linesAdded(input: OrderLinesAddedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[17], opt = this._transport.mergeOptions(options); + const method = this.methods[18], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: LinesDetected */ linesDetected(input: OrderLinesDetectedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[18], opt = this._transport.mergeOptions(options); + const method = this.methods[19], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: Sanitised */ sanitised(input: OrderSanitisedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[19], opt = this._transport.mergeOptions(options); + const method = this.methods[20], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: CustomFieldsUpdated */ customFieldsUpdated(input: OrderCustomFieldsUpdatedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[20], opt = this._transport.mergeOptions(options); + const method = this.methods[21], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: PreparationExpected */ preparationExpected(input: OrderPreparationExpectedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[21], opt = this._transport.mergeOptions(options); + const method = this.methods[22], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: PreparationStarted */ preparationStarted(input: OrderPreparationStartedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[22], opt = this._transport.mergeOptions(options); + const method = this.methods[23], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: PreparationCompleted */ preparationCompleted(input: OrderPreparationCompletedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[23], opt = this._transport.mergeOptions(options); + const method = this.methods[24], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: TransportExpected */ transportExpected(input: OrderTransportExpectedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[24], opt = this._transport.mergeOptions(options); + const method = this.methods[25], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: TransportStarted */ transportStarted(input: OrderTransportStartedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[25], opt = this._transport.mergeOptions(options); + const method = this.methods[26], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: TransportCompleted */ transportCompleted(input: OrderTransportCompletedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[26], opt = this._transport.mergeOptions(options); + const method = this.methods[27], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: ReceiptExpected */ receiptExpected(input: OrderReceiptExpectedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[27], opt = this._transport.mergeOptions(options); + const method = this.methods[28], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: ReceiptStarted */ receiptStarted(input: OrderReceiptStartedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[28], opt = this._transport.mergeOptions(options); + const method = this.methods[29], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: ReceiptCompleted */ receiptCompleted(input: OrderReceiptCompletedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[29], opt = this._transport.mergeOptions(options); + const method = this.methods[30], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: AppointmentUpdated */ appointmentUpdated(input: OrderAppointmentUpdatedRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[30], opt = this._transport.mergeOptions(options); + const method = this.methods[31], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } /** * @generated from protobuf rpc: AppointmentBookingDisabled */ appointmentBookingDisabled(input: OrderAppointmentBookingDisabledRequest, options?: RpcOptions): UnaryCall { - const method = this.methods[31], opt = this._transport.mergeOptions(options); + const method = this.methods[32], opt = this._transport.mergeOptions(options); return stackIntercept("unary", this._transport, method, opt, input); } } diff --git a/orderInput.ts b/orderInput.ts index 98c8936..85c18db 100644 --- a/orderInput.ts +++ b/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 { */ export const OrderCompletedResponse = new OrderCompletedResponse$Type(); // @generated message type with reflection information, may provide speed optimized methods +class OrderAnticipatedClosedPayload$Type extends MessageType { + constructor() { + super("api.OrderAnticipatedClosedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AnticipatedClosed" }); + } + create(value?: PartialMessage): OrderAnticipatedClosedPayload { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(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 { + 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 { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(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 { + 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 { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(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 { + 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 { + const message = globalThis.Object.create((this.messagePrototype!)); + if (value !== undefined) + reflectionMergePartial(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 { 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 }, diff --git a/package.json b/package.json index 56b28e5..993023b 100644 --- a/package.json +++ b/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",