reflex-platform/npm-core-sdk
0
Fork 0
Code Pull Requests Projects Releases Wiki Activity

Latest generation

Browse Source
This commit is contained in:
ci core model
2026-06-18 06:59:27 +00:00
parent 622d5262d2
commit 5c2bd89f12
4 changed files with 315 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
order.ts
View File

@@ -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);

57
orderInput.client.ts
View File

@@ -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);
}
}

266
orderInput.ts
View File

@@ -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 },

2
package.json
View File

@@ -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",