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
2025-03-21 09:55:29 +00:00
parent d4d259a6cc
commit d42679cbd6
15 changed files with 144 additions and 8540 deletions
Download Patch File Download Diff File Expand all files Collapse all files

635
actorInput.ts
View File

@@ -15,9 +15,8 @@ import { ClaimSummary } from "./shared";
import { AttachmentSummary } from "./shared";
import { ActorSnapshot } from "./repositoryShared";
import { ResponseHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { CarrierService } from "./repositoryShared";
import { ActorTypology } from "./repositoryShared";
import { Address } from "./repositoryShared";
@@ -125,25 +124,6 @@ export interface ActorCreatedPayload {
*/
connectionIdentifierPrefixes: string[];
}
/**
* Event message
*
* @generated from protobuf message api.ActorCreatedEvent
*/
export interface ActorCreatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorCreatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorCreatedPayload;
}
/**
* API Request
*
@@ -231,25 +211,6 @@ export interface ActorCreatedv2Payload {
*/
carrierServices: CarrierService[];
}
/**
* Event message
*
* @generated from protobuf message api.ActorCreatedv2Event
*/
export interface ActorCreatedv2Event {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorCreatedv2Payload;
}
/**
* API Request
*
@@ -291,25 +252,6 @@ export interface ActorCreatedv2Response {
*/
export interface ActorDeletedPayload {
}
/**
* Event message
*
* @generated from protobuf message api.ActorDeletedEvent
*/
export interface ActorDeletedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorDeletedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorDeletedPayload;
}
/**
* API Request
*
@@ -355,25 +297,6 @@ export interface ActorSnapshotCompletedPayload {
*/
snapshot?: ActorSnapshot;
}
/**
* Event message
*
* @generated from protobuf message api.ActorSnapshotCompletedEvent
*/
export interface ActorSnapshotCompletedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorSnapshotCompletedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorSnapshotCompletedPayload;
}
/**
* API Request
*
@@ -420,23 +343,6 @@ export interface ActorAttachmentAddedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.ActorAttachmentAddedEvent
*/
export interface ActorAttachmentAddedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorAttachmentAddedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorAttachmentAddedPayload;
}
/**
* @generated from protobuf message api.ActorAttachmentAddedRequest
*/
@@ -479,23 +385,6 @@ export interface ActorAttachmentRemovedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.ActorAttachmentRemovedEvent
*/
export interface ActorAttachmentRemovedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorAttachmentRemovedPayload;
}
/**
* @generated from protobuf message api.ActorAttachmentRemovedRequest
*/
@@ -538,23 +427,6 @@ export interface ActorClaimAddedPayload {
*/
claims: ClaimSummary[];
}
/**
* @generated from protobuf message api.ActorClaimAddedEvent
*/
export interface ActorClaimAddedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorClaimAddedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorClaimAddedPayload;
}
/**
* @generated from protobuf message api.ActorClaimAddedRequest
*/
@@ -602,23 +474,6 @@ export interface ActorMetaDataUpdatedPayload {
*/
metaData: MetadataElement[];
}
/**
* @generated from protobuf message api.ActorMetaDataUpdatedEvent
*/
export interface ActorMetaDataUpdatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ActorMetaDataUpdatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ActorMetaDataUpdatedPayload;
}
/**
* @generated from protobuf message api.ActorMetaDataUpdatedRequest
*/
@@ -671,7 +526,7 @@ class ActorCreatedPayload$Type extends MessageType<ActorCreatedPayload> {
{ no: 21, name: "ShipFromPartnerAppID", kind: "scalar", jsonName: "ShipFromPartnerAppID", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Must be existing partner ID" } } },
{ no: 26, name: "PhotoURI", kind: "scalar", jsonName: "PhotoURI", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { example: "\"https://reflex-visibility-forever.jpg\"" }, "api.viewType": { Types: [{ Context: "*", Type: "image" }] } } },
{ no: 28, name: "ConnectionIdentifierPrefixes", kind: "scalar", jsonName: "ConnectionIdentifierPrefixes", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { repeated: { items: { string: { pattern: "^[a-zA-Z0-9]*" } } } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Created" });
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Created", "api.preAggMethods": "checkPartnerAppId" });
}
create(value?: PartialMessage<ActorCreatedPayload>): ActorCreatedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -832,66 +687,6 @@ class ActorCreatedPayload$Type extends MessageType<ActorCreatedPayload> {
*/
export const ActorCreatedPayload = new ActorCreatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorCreatedEvent$Type extends MessageType<ActorCreatedEvent> {
constructor() {
super("api.ActorCreatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorCreatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "EntityID", "ActorCreatedPayload"] } }, "api.messageType": "Event", "api.inputEvent": "Created", "api.preAggMethods": "checkPartnerAppId" });
}
create(value?: PartialMessage<ActorCreatedEvent>): ActorCreatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorCreatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorCreatedEvent): ActorCreatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorCreatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorCreatedPayload.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: ActorCreatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorCreatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorCreatedPayload.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.ActorCreatedEvent
*/
export const ActorCreatedEvent = new ActorCreatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorCreatedRequest$Type extends MessageType<ActorCreatedRequest> {
constructor() {
super("api.ActorCreatedRequest", [
@@ -1123,66 +918,6 @@ class ActorCreatedv2Payload$Type extends MessageType<ActorCreatedv2Payload> {
*/
export const ActorCreatedv2Payload = new ActorCreatedv2Payload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorCreatedv2Event$Type extends MessageType<ActorCreatedv2Event> {
constructor() {
super("api.ActorCreatedv2Event", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorCreatedv2Payload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Createdv2" });
}
create(value?: PartialMessage<ActorCreatedv2Event>): ActorCreatedv2Event {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorCreatedv2Event>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorCreatedv2Event): ActorCreatedv2Event {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorCreatedv2Payload.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: ActorCreatedv2Event, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorCreatedv2Payload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorCreatedv2Payload.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.ActorCreatedv2Event
*/
export const ActorCreatedv2Event = new ActorCreatedv2Event$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorCreatedv2Request$Type extends MessageType<ActorCreatedv2Request> {
constructor() {
super("api.ActorCreatedv2Request", [
@@ -1334,66 +1069,6 @@ class ActorDeletedPayload$Type extends MessageType<ActorDeletedPayload> {
*/
export const ActorDeletedPayload = new ActorDeletedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorDeletedEvent$Type extends MessageType<ActorDeletedEvent> {
constructor() {
super("api.ActorDeletedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorDeletedPayload }
], { "api.messageType": "Event", "api.inputEvent": "Deleted" });
}
create(value?: PartialMessage<ActorDeletedEvent>): ActorDeletedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorDeletedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorDeletedEvent): ActorDeletedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorDeletedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorDeletedPayload.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: ActorDeletedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorDeletedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorDeletedPayload.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.ActorDeletedEvent
*/
export const ActorDeletedEvent = new ActorDeletedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorDeletedRequest$Type extends MessageType<ActorDeletedRequest> {
constructor() {
super("api.ActorDeletedRequest", [
@@ -1553,66 +1228,6 @@ class ActorSnapshotCompletedPayload$Type extends MessageType<ActorSnapshotComple
*/
export const ActorSnapshotCompletedPayload = new ActorSnapshotCompletedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorSnapshotCompletedEvent$Type extends MessageType<ActorSnapshotCompletedEvent> {
constructor() {
super("api.ActorSnapshotCompletedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorSnapshotCompletedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "SnapshotCompleted" });
}
create(value?: PartialMessage<ActorSnapshotCompletedEvent>): ActorSnapshotCompletedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorSnapshotCompletedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorSnapshotCompletedEvent): ActorSnapshotCompletedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorSnapshotCompletedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorSnapshotCompletedPayload.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: ActorSnapshotCompletedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorSnapshotCompletedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorSnapshotCompletedPayload.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.ActorSnapshotCompletedEvent
*/
export const ActorSnapshotCompletedEvent = new ActorSnapshotCompletedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorSnapshotCompletedRequest$Type extends MessageType<ActorSnapshotCompletedRequest> {
constructor() {
super("api.ActorSnapshotCompletedRequest", [
@@ -1730,7 +1345,7 @@ class ActorAttachmentAddedPayload$Type extends MessageType<ActorAttachmentAddedP
constructor() {
super("api.ActorAttachmentAddedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments added per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<ActorAttachmentAddedPayload>): ActorAttachmentAddedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1773,66 +1388,6 @@ class ActorAttachmentAddedPayload$Type extends MessageType<ActorAttachmentAddedP
*/
export const ActorAttachmentAddedPayload = new ActorAttachmentAddedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorAttachmentAddedEvent$Type extends MessageType<ActorAttachmentAddedEvent> {
constructor() {
super("api.ActorAttachmentAddedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorAttachmentAddedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<ActorAttachmentAddedEvent>): ActorAttachmentAddedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorAttachmentAddedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorAttachmentAddedEvent): ActorAttachmentAddedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorAttachmentAddedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorAttachmentAddedPayload.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: ActorAttachmentAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorAttachmentAddedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorAttachmentAddedPayload.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.ActorAttachmentAddedEvent
*/
export const ActorAttachmentAddedEvent = new ActorAttachmentAddedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorAttachmentAddedRequest$Type extends MessageType<ActorAttachmentAddedRequest> {
constructor() {
super("api.ActorAttachmentAddedRequest", [
@@ -1950,7 +1505,7 @@ class ActorAttachmentRemovedPayload$Type extends MessageType<ActorAttachmentRemo
constructor() {
super("api.ActorAttachmentRemovedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments removed per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<ActorAttachmentRemovedPayload>): ActorAttachmentRemovedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1993,66 +1548,6 @@ class ActorAttachmentRemovedPayload$Type extends MessageType<ActorAttachmentRemo
*/
export const ActorAttachmentRemovedPayload = new ActorAttachmentRemovedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorAttachmentRemovedEvent$Type extends MessageType<ActorAttachmentRemovedEvent> {
constructor() {
super("api.ActorAttachmentRemovedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorAttachmentRemovedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<ActorAttachmentRemovedEvent>): ActorAttachmentRemovedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorAttachmentRemovedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorAttachmentRemovedEvent): ActorAttachmentRemovedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorAttachmentRemovedPayload.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: ActorAttachmentRemovedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorAttachmentRemovedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorAttachmentRemovedPayload.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.ActorAttachmentRemovedEvent
*/
export const ActorAttachmentRemovedEvent = new ActorAttachmentRemovedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorAttachmentRemovedRequest$Type extends MessageType<ActorAttachmentRemovedRequest> {
constructor() {
super("api.ActorAttachmentRemovedRequest", [
@@ -2170,7 +1665,7 @@ class ActorClaimAddedPayload$Type extends MessageType<ActorClaimAddedPayload> {
constructor() {
super("api.ActorClaimAddedPayload", [
{ no: 1, name: "Claims", kind: "message", jsonName: "Claims", repeat: 1 /*RepeatType.PACKED*/, T: () => ClaimSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of claims added per type" }, "api.aggKey": "ClaimTypeID" } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "ClaimAdded" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "ClaimAdded", "api.preAggMethods": "addClaim" });
}
create(value?: PartialMessage<ActorClaimAddedPayload>): ActorClaimAddedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -2213,66 +1708,6 @@ class ActorClaimAddedPayload$Type extends MessageType<ActorClaimAddedPayload> {
*/
export const ActorClaimAddedPayload = new ActorClaimAddedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorClaimAddedEvent$Type extends MessageType<ActorClaimAddedEvent> {
constructor() {
super("api.ActorClaimAddedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorClaimAddedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "ClaimAdded", "api.preAggMethods": "addClaim" });
}
create(value?: PartialMessage<ActorClaimAddedEvent>): ActorClaimAddedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorClaimAddedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorClaimAddedEvent): ActorClaimAddedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorClaimAddedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorClaimAddedPayload.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: ActorClaimAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorClaimAddedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorClaimAddedPayload.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.ActorClaimAddedEvent
*/
export const ActorClaimAddedEvent = new ActorClaimAddedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorClaimAddedRequest$Type extends MessageType<ActorClaimAddedRequest> {
constructor() {
super("api.ActorClaimAddedRequest", [
@@ -2433,66 +1868,6 @@ class ActorMetaDataUpdatedPayload$Type extends MessageType<ActorMetaDataUpdatedP
*/
export const ActorMetaDataUpdatedPayload = new ActorMetaDataUpdatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorMetaDataUpdatedEvent$Type extends MessageType<ActorMetaDataUpdatedEvent> {
constructor() {
super("api.ActorMetaDataUpdatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ActorMetaDataUpdatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "MetaDataUpdated" });
}
create(value?: PartialMessage<ActorMetaDataUpdatedEvent>): ActorMetaDataUpdatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorMetaDataUpdatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorMetaDataUpdatedEvent): ActorMetaDataUpdatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ActorMetaDataUpdatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ActorMetaDataUpdatedPayload.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: ActorMetaDataUpdatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorMetaDataUpdatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ActorMetaDataUpdatedPayload.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.ActorMetaDataUpdatedEvent
*/
export const ActorMetaDataUpdatedEvent = new ActorMetaDataUpdatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorMetaDataUpdatedRequest$Type extends MessageType<ActorMetaDataUpdatedRequest> {
constructor() {
super("api.ActorMetaDataUpdatedRequest", [

1034
claimInput.ts
View File

File diff suppressed because it is too large Load Diff

2030
executionflowInput.ts
View File

File diff suppressed because it is too large Load Diff

1103
handlingunitInput.ts
View File

File diff suppressed because it is too large Load Diff

42
itemInput.client.ts
View File

@@ -32,6 +32,8 @@ import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
// option (payload) = true;
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
//
// repeated ClaimSummary Claims = 1
// [
// (aggKey) = "ClaimTypeID",
@@ -39,24 +41,7 @@ import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
// description: "Number of claims added per type"}
// ];
// }
// message ItemClaimAddedEvent
// {
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
// EventHeader Header = 1
// [
// (validate.rules).message.required = true
// ];
// EntityID ID = 2
// [
// (validate.rules).message.required = true
// ];
// ItemClaimAddedPayload Payload = 3
// [
// (validate.rules).message.required = true
// ];
// }
//
// message ItemClaimAddedRequest {
// option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema) = {
// json_schema: {
@@ -134,6 +119,8 @@ export interface IItemInputAPIClient {
// option (payload) = true;
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
//
// repeated ClaimSummary Claims = 1
// [
// (aggKey) = "ClaimTypeID",
@@ -141,24 +128,7 @@ export interface IItemInputAPIClient {
// description: "Number of claims added per type"}
// ];
// }
// message ItemClaimAddedEvent
// {
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
// EventHeader Header = 1
// [
// (validate.rules).message.required = true
// ];
// EntityID ID = 2
// [
// (validate.rules).message.required = true
// ];
// ItemClaimAddedPayload Payload = 3
// [
// (validate.rules).message.required = true
// ];
// }
//
// message ItemClaimAddedRequest {
// option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema) = {
// json_schema: {

641
itemInput.ts
View File

@@ -13,9 +13,8 @@ import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { AttachmentSummary } from "./shared";
import { ResponseHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { LogisticVariant } from "./repositoryShared";
import { TradeItemDescriptions } from "./repositoryShared";
import { ExpiryConstraint } from "./repositoryShared";
@@ -55,25 +54,6 @@ export interface ItemCreatedPayload {
*/
logisticVariants: LogisticVariant[];
}
/**
* Event message
*
* @generated from protobuf message api.ItemCreatedEvent
*/
export interface ItemCreatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemCreatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemCreatedPayload;
}
/**
* API Request
*
@@ -121,25 +101,6 @@ export interface ItemMetaDataUpdatedPayload {
*/
metaData: MetadataElement[];
}
/**
* Event message
*
* @generated from protobuf message api.ItemMetaDataUpdatedEvent
*/
export interface ItemMetaDataUpdatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemMetaDataUpdatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemMetaDataUpdatedPayload;
}
/**
* API Request
*
@@ -188,25 +149,6 @@ export interface ItemLogisticVariantUpdatedPayload {
*/
logisticVariants: LogisticVariant[];
}
/**
* Event message
*
* @generated from protobuf message api.ItemLogisticVariantUpdatedEvent
*/
export interface ItemLogisticVariantUpdatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemLogisticVariantUpdatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemLogisticVariantUpdatedPayload;
}
/**
* API Request
*
@@ -255,25 +197,6 @@ export interface ItemLogisticVariantRemovedPayload {
*/
removedLogisticVariantIDs: string[];
}
/**
* Event message
*
* @generated from protobuf message api.ItemLogisticVariantRemovedEvent
*/
export interface ItemLogisticVariantRemovedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemLogisticVariantRemovedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemLogisticVariantRemovedPayload;
}
/**
* API Request
*
@@ -319,25 +242,6 @@ export interface ItemLogisticVariantRemovedResponse {
*/
export interface ItemDeletedPayload {
}
/**
* Event message
*
* @generated from protobuf message api.ItemDeletedEvent
*/
export interface ItemDeletedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemDeletedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemDeletedPayload;
}
/**
* API Request
*
@@ -387,25 +291,6 @@ export interface ItemDescriptionUpdatedPayload {
*/
descriptionsByLanguage: TradeItemDescriptions[]; // @option language
}
/**
* Event message
*
* @generated from protobuf message api.ItemDescriptionUpdatedEvent
*/
export interface ItemDescriptionUpdatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemDescriptionUpdatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemDescriptionUpdatedPayload;
}
/**
* API Request
*
@@ -452,23 +337,6 @@ export interface ItemAttachmentAddedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.ItemAttachmentAddedEvent
*/
export interface ItemAttachmentAddedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemAttachmentAddedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemAttachmentAddedPayload;
}
/**
* @generated from protobuf message api.ItemAttachmentAddedRequest
*/
@@ -511,23 +379,6 @@ export interface ItemAttachmentRemovedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.ItemAttachmentRemovedEvent
*/
export interface ItemAttachmentRemovedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.ItemAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: ItemAttachmentRemovedPayload;
}
/**
* @generated from protobuf message api.ItemAttachmentRemovedRequest
*/
@@ -567,7 +418,7 @@ class ItemCreatedPayload$Type extends MessageType<ItemCreatedPayload> {
{ no: 7, name: "PhotoURI", kind: "scalar", jsonName: "PhotoURI", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { example: "\"https://reflex-visibility-forever.jpg\"" }, "api.viewType": { Types: [{ Context: "*", Type: "image" }] } } },
{ no: 3, name: "DescriptionsByLanguage", kind: "message", jsonName: "DescriptionsByLanguage", repeat: 1 /*RepeatType.PACKED*/, T: () => TradeItemDescriptions, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } },
{ no: 4, name: "LogisticVariants", kind: "message", jsonName: "LogisticVariants", repeat: 1 /*RepeatType.PACKED*/, T: () => LogisticVariant, options: { "validate.rules": { repeated: { uniqueBaseLV: true, knownRefLV: true } }, "api.aggKey": "LVID" } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Created" });
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Event Payload" } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Created", "api.postAggMethods": "computeEquivalentLVBaseQuantity,defineExpiration,propagateLVBranches", "api.preAggMethods": "checkBaseLV" });
}
create(value?: PartialMessage<ItemCreatedPayload>): ItemCreatedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -637,66 +488,6 @@ class ItemCreatedPayload$Type extends MessageType<ItemCreatedPayload> {
*/
export const ItemCreatedPayload = new ItemCreatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemCreatedEvent$Type extends MessageType<ItemCreatedEvent> {
constructor() {
super("api.ItemCreatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemCreatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Created", "api.postAggMethods": "computeEquivalentLVBaseQuantity,defineExpiration,propagateLVBranches", "api.preAggMethods": "checkBaseLV" });
}
create(value?: PartialMessage<ItemCreatedEvent>): ItemCreatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemCreatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemCreatedEvent): ItemCreatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemCreatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemCreatedPayload.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: ItemCreatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemCreatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemCreatedPayload.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.ItemCreatedEvent
*/
export const ItemCreatedEvent = new ItemCreatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemCreatedRequest$Type extends MessageType<ItemCreatedRequest> {
constructor() {
super("api.ItemCreatedRequest", [
@@ -857,66 +648,6 @@ class ItemMetaDataUpdatedPayload$Type extends MessageType<ItemMetaDataUpdatedPay
*/
export const ItemMetaDataUpdatedPayload = new ItemMetaDataUpdatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemMetaDataUpdatedEvent$Type extends MessageType<ItemMetaDataUpdatedEvent> {
constructor() {
super("api.ItemMetaDataUpdatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemMetaDataUpdatedPayload }
], { "api.messageType": "Event", "api.inputEvent": "MetaDataUpdated" });
}
create(value?: PartialMessage<ItemMetaDataUpdatedEvent>): ItemMetaDataUpdatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemMetaDataUpdatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemMetaDataUpdatedEvent): ItemMetaDataUpdatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemMetaDataUpdatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemMetaDataUpdatedPayload.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: ItemMetaDataUpdatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemMetaDataUpdatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemMetaDataUpdatedPayload.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.ItemMetaDataUpdatedEvent
*/
export const ItemMetaDataUpdatedEvent = new ItemMetaDataUpdatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemMetaDataUpdatedRequest$Type extends MessageType<ItemMetaDataUpdatedRequest> {
constructor() {
super("api.ItemMetaDataUpdatedRequest", [
@@ -1034,7 +765,7 @@ class ItemLogisticVariantUpdatedPayload$Type extends MessageType<ItemLogisticVar
constructor() {
super("api.ItemLogisticVariantUpdatedPayload", [
{ no: 1, name: "LogisticVariants", kind: "message", jsonName: "LogisticVariants", repeat: 1 /*RepeatType.PACKED*/, T: () => LogisticVariant, options: { "api.aggKey": "LVID" } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LogisticVariantUpdated" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LogisticVariantUpdated", "api.postAggMethods": "computeEquivalentLVBaseQuantity,propagateLVBranches", "api.preAggMethods": "checkBaseLV" });
}
create(value?: PartialMessage<ItemLogisticVariantUpdatedPayload>): ItemLogisticVariantUpdatedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1077,66 +808,6 @@ class ItemLogisticVariantUpdatedPayload$Type extends MessageType<ItemLogisticVar
*/
export const ItemLogisticVariantUpdatedPayload = new ItemLogisticVariantUpdatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemLogisticVariantUpdatedEvent$Type extends MessageType<ItemLogisticVariantUpdatedEvent> {
constructor() {
super("api.ItemLogisticVariantUpdatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemLogisticVariantUpdatedPayload }
], { "api.messageType": "Event", "api.inputEvent": "LogisticVariantUpdated", "api.postAggMethods": "computeEquivalentLVBaseQuantity,propagateLVBranches", "api.preAggMethods": "checkBaseLV" });
}
create(value?: PartialMessage<ItemLogisticVariantUpdatedEvent>): ItemLogisticVariantUpdatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemLogisticVariantUpdatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemLogisticVariantUpdatedEvent): ItemLogisticVariantUpdatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemLogisticVariantUpdatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemLogisticVariantUpdatedPayload.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: ItemLogisticVariantUpdatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemLogisticVariantUpdatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemLogisticVariantUpdatedPayload.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.ItemLogisticVariantUpdatedEvent
*/
export const ItemLogisticVariantUpdatedEvent = new ItemLogisticVariantUpdatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemLogisticVariantUpdatedRequest$Type extends MessageType<ItemLogisticVariantUpdatedRequest> {
constructor() {
super("api.ItemLogisticVariantUpdatedRequest", [
@@ -1254,7 +925,7 @@ class ItemLogisticVariantRemovedPayload$Type extends MessageType<ItemLogisticVar
constructor() {
super("api.ItemLogisticVariantRemovedPayload", [
{ no: 1, name: "RemovedLogisticVariantIDs", kind: "scalar", jsonName: "RemovedLogisticVariantIDs", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LogisticVariantRemoved", "api.postAggMethods": "computeEquivalentLVBaseQuantity,propagateLVBranches" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "LogisticVariantRemoved", "api.postAggMethods": "computeEquivalentLVBaseQuantity,propagateLVBranches", "api.preAggMethods": "removeLVs" });
}
create(value?: PartialMessage<ItemLogisticVariantRemovedPayload>): ItemLogisticVariantRemovedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1297,66 +968,6 @@ class ItemLogisticVariantRemovedPayload$Type extends MessageType<ItemLogisticVar
*/
export const ItemLogisticVariantRemovedPayload = new ItemLogisticVariantRemovedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemLogisticVariantRemovedEvent$Type extends MessageType<ItemLogisticVariantRemovedEvent> {
constructor() {
super("api.ItemLogisticVariantRemovedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemLogisticVariantRemovedPayload }
], { "api.messageType": "Event", "api.inputEvent": "LogisticVariantRemoved", "api.preAggMethods": "removeLVs" });
}
create(value?: PartialMessage<ItemLogisticVariantRemovedEvent>): ItemLogisticVariantRemovedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemLogisticVariantRemovedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemLogisticVariantRemovedEvent): ItemLogisticVariantRemovedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemLogisticVariantRemovedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemLogisticVariantRemovedPayload.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: ItemLogisticVariantRemovedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemLogisticVariantRemovedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemLogisticVariantRemovedPayload.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.ItemLogisticVariantRemovedEvent
*/
export const ItemLogisticVariantRemovedEvent = new ItemLogisticVariantRemovedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemLogisticVariantRemovedRequest$Type extends MessageType<ItemLogisticVariantRemovedRequest> {
constructor() {
super("api.ItemLogisticVariantRemovedRequest", [
@@ -1508,66 +1119,6 @@ class ItemDeletedPayload$Type extends MessageType<ItemDeletedPayload> {
*/
export const ItemDeletedPayload = new ItemDeletedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemDeletedEvent$Type extends MessageType<ItemDeletedEvent> {
constructor() {
super("api.ItemDeletedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemDeletedPayload }
], { "api.messageType": "Event", "api.inputEvent": "Deleted" });
}
create(value?: PartialMessage<ItemDeletedEvent>): ItemDeletedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemDeletedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemDeletedEvent): ItemDeletedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemDeletedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemDeletedPayload.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: ItemDeletedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemDeletedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemDeletedPayload.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.ItemDeletedEvent
*/
export const ItemDeletedEvent = new ItemDeletedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemDeletedRequest$Type extends MessageType<ItemDeletedRequest> {
constructor() {
super("api.ItemDeletedRequest", [
@@ -1728,66 +1279,6 @@ class ItemDescriptionUpdatedPayload$Type extends MessageType<ItemDescriptionUpda
*/
export const ItemDescriptionUpdatedPayload = new ItemDescriptionUpdatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemDescriptionUpdatedEvent$Type extends MessageType<ItemDescriptionUpdatedEvent> {
constructor() {
super("api.ItemDescriptionUpdatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemDescriptionUpdatedPayload }
], { "api.messageType": "Event", "api.inputEvent": "DescriptionUpdated" });
}
create(value?: PartialMessage<ItemDescriptionUpdatedEvent>): ItemDescriptionUpdatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemDescriptionUpdatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemDescriptionUpdatedEvent): ItemDescriptionUpdatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemDescriptionUpdatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemDescriptionUpdatedPayload.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: ItemDescriptionUpdatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemDescriptionUpdatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemDescriptionUpdatedPayload.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.ItemDescriptionUpdatedEvent
*/
export const ItemDescriptionUpdatedEvent = new ItemDescriptionUpdatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemDescriptionUpdatedRequest$Type extends MessageType<ItemDescriptionUpdatedRequest> {
constructor() {
super("api.ItemDescriptionUpdatedRequest", [
@@ -1905,7 +1396,7 @@ class ItemAttachmentAddedPayload$Type extends MessageType<ItemAttachmentAddedPay
constructor() {
super("api.ItemAttachmentAddedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments added per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<ItemAttachmentAddedPayload>): ItemAttachmentAddedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1948,66 +1439,6 @@ class ItemAttachmentAddedPayload$Type extends MessageType<ItemAttachmentAddedPay
*/
export const ItemAttachmentAddedPayload = new ItemAttachmentAddedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemAttachmentAddedEvent$Type extends MessageType<ItemAttachmentAddedEvent> {
constructor() {
super("api.ItemAttachmentAddedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemAttachmentAddedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<ItemAttachmentAddedEvent>): ItemAttachmentAddedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemAttachmentAddedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemAttachmentAddedEvent): ItemAttachmentAddedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemAttachmentAddedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemAttachmentAddedPayload.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: ItemAttachmentAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemAttachmentAddedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemAttachmentAddedPayload.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.ItemAttachmentAddedEvent
*/
export const ItemAttachmentAddedEvent = new ItemAttachmentAddedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemAttachmentAddedRequest$Type extends MessageType<ItemAttachmentAddedRequest> {
constructor() {
super("api.ItemAttachmentAddedRequest", [
@@ -2125,7 +1556,7 @@ class ItemAttachmentRemovedPayload$Type extends MessageType<ItemAttachmentRemove
constructor() {
super("api.ItemAttachmentRemovedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments removed per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<ItemAttachmentRemovedPayload>): ItemAttachmentRemovedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -2168,66 +1599,6 @@ class ItemAttachmentRemovedPayload$Type extends MessageType<ItemAttachmentRemove
*/
export const ItemAttachmentRemovedPayload = new ItemAttachmentRemovedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemAttachmentRemovedEvent$Type extends MessageType<ItemAttachmentRemovedEvent> {
constructor() {
super("api.ItemAttachmentRemovedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => ItemAttachmentRemovedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<ItemAttachmentRemovedEvent>): ItemAttachmentRemovedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemAttachmentRemovedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemAttachmentRemovedEvent): ItemAttachmentRemovedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.ItemAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = ItemAttachmentRemovedPayload.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: ItemAttachmentRemovedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemAttachmentRemovedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
ItemAttachmentRemovedPayload.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.ItemAttachmentRemovedEvent
*/
export const ItemAttachmentRemovedEvent = new ItemAttachmentRemovedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemAttachmentRemovedRequest$Type extends MessageType<ItemAttachmentRemovedRequest> {
constructor() {
super("api.ItemAttachmentRemovedRequest", [

546
movementInput.ts
View File

@@ -14,11 +14,10 @@ import { MessageType } from "@protobuf-ts/runtime";
import { AttachmentSummary } from "./shared";
import { ClaimSummary } from "./shared";
import { QuantityInLV } from "./warehousingShared";
import { EntityID } from "./shared";
import { ResponseHeader } from "./shared";
import { NoID } from "./shared";
import { RequestProjectHeader } from "./shared";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
import { StockMovement } from "./warehousingShared";
import { ActorPayload } from "./actor";
import { EnrichedGoods } from "./warehousingShared";
@@ -52,23 +51,6 @@ export interface MovementCreatedPayload {
*/
movement?: StockMovement;
}
/**
* @generated from protobuf message api.MovementCreatedEvent
*/
export interface MovementCreatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.MovementCreatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: MovementCreatedPayload;
}
/**
* @generated from protobuf message api.MovementCreatedRequest
*/
@@ -141,23 +123,6 @@ export interface MovementGeneratedPayload {
*/
quantityInBaseLV?: QuantityInLV;
}
/**
* @generated from protobuf message api.MovementGeneratedEvent
*/
export interface MovementGeneratedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.MovementGeneratedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: MovementGeneratedPayload;
}
/**
* @generated from protobuf message api.MovementGeneratedRequest
*/
@@ -208,23 +173,6 @@ export interface MovementStockValueUpdatedPayload {
*/
quantityInBaseLV?: QuantityInLV; // Stock value juste after the movement was applied
}
/**
* @generated from protobuf message api.MovementStockValueUpdatedEvent
*/
export interface MovementStockValueUpdatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.MovementStockValueUpdatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: MovementStockValueUpdatedPayload;
}
/**
* @generated from protobuf message api.MovementStockValueUpdatedRequest
*/
@@ -267,23 +215,6 @@ export interface MovementClaimAddedPayload {
*/
claims: ClaimSummary[];
}
/**
* @generated from protobuf message api.MovementClaimAddedEvent
*/
export interface MovementClaimAddedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.MovementClaimAddedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: MovementClaimAddedPayload;
}
/**
* @generated from protobuf message api.MovementClaimAddedRequest
*/
@@ -326,23 +257,6 @@ export interface MovementAttachmentAddedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.MovementAttachmentAddedEvent
*/
export interface MovementAttachmentAddedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.MovementAttachmentAddedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: MovementAttachmentAddedPayload;
}
/**
* @generated from protobuf message api.MovementAttachmentAddedRequest
*/
@@ -385,23 +299,6 @@ export interface MovementAttachmentRemovedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.MovementAttachmentRemovedEvent
*/
export interface MovementAttachmentRemovedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.MovementAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: MovementAttachmentRemovedPayload;
}
/**
* @generated from protobuf message api.MovementAttachmentRemovedRequest
*/
@@ -439,25 +336,6 @@ export interface MovementAttachmentRemovedResponse {
*/
export interface MovementDeletedPayload {
}
/**
* Event message
*
* @generated from protobuf message api.MovementDeletedEvent
*/
export interface MovementDeletedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.MovementDeletedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: MovementDeletedPayload;
}
/**
* API Request
*
@@ -561,66 +439,6 @@ class MovementCreatedPayload$Type extends MessageType<MovementCreatedPayload> {
*/
export const MovementCreatedPayload = new MovementCreatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementCreatedEvent$Type extends MessageType<MovementCreatedEvent> {
constructor() {
super("api.MovementCreatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => MovementCreatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Created" });
}
create(value?: PartialMessage<MovementCreatedEvent>): MovementCreatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementCreatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementCreatedEvent): MovementCreatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.MovementCreatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = MovementCreatedPayload.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: MovementCreatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementCreatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
MovementCreatedPayload.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.MovementCreatedEvent
*/
export const MovementCreatedEvent = new MovementCreatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementCreatedRequest$Type extends MessageType<MovementCreatedRequest> {
constructor() {
super("api.MovementCreatedRequest", [
@@ -809,66 +627,6 @@ class MovementGeneratedPayload$Type extends MessageType<MovementGeneratedPayload
*/
export const MovementGeneratedPayload = new MovementGeneratedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementGeneratedEvent$Type extends MessageType<MovementGeneratedEvent> {
constructor() {
super("api.MovementGeneratedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => MovementGeneratedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Generated" });
}
create(value?: PartialMessage<MovementGeneratedEvent>): MovementGeneratedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementGeneratedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementGeneratedEvent): MovementGeneratedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.MovementGeneratedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = MovementGeneratedPayload.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: MovementGeneratedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementGeneratedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
MovementGeneratedPayload.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.MovementGeneratedEvent
*/
export const MovementGeneratedEvent = new MovementGeneratedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementGeneratedRequest$Type extends MessageType<MovementGeneratedRequest> {
constructor() {
super("api.MovementGeneratedRequest", [
@@ -1028,66 +786,6 @@ class MovementStockValueUpdatedPayload$Type extends MessageType<MovementStockVal
*/
export const MovementStockValueUpdatedPayload = new MovementStockValueUpdatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementStockValueUpdatedEvent$Type extends MessageType<MovementStockValueUpdatedEvent> {
constructor() {
super("api.MovementStockValueUpdatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => MovementStockValueUpdatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "StockValueUpdated" });
}
create(value?: PartialMessage<MovementStockValueUpdatedEvent>): MovementStockValueUpdatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementStockValueUpdatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementStockValueUpdatedEvent): MovementStockValueUpdatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.MovementStockValueUpdatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = MovementStockValueUpdatedPayload.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: MovementStockValueUpdatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementStockValueUpdatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
MovementStockValueUpdatedPayload.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.MovementStockValueUpdatedEvent
*/
export const MovementStockValueUpdatedEvent = new MovementStockValueUpdatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementStockValueUpdatedRequest$Type extends MessageType<MovementStockValueUpdatedRequest> {
constructor() {
super("api.MovementStockValueUpdatedRequest", [
@@ -1205,7 +903,7 @@ class MovementClaimAddedPayload$Type extends MessageType<MovementClaimAddedPaylo
constructor() {
super("api.MovementClaimAddedPayload", [
{ no: 1, name: "Claims", kind: "message", jsonName: "Claims", repeat: 1 /*RepeatType.PACKED*/, T: () => ClaimSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of claims added per type" }, "api.aggKey": "ClaimTypeID" } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "ClaimAdded" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "ClaimAdded", "api.preAggMethods": "addClaim" });
}
create(value?: PartialMessage<MovementClaimAddedPayload>): MovementClaimAddedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1248,66 +946,6 @@ class MovementClaimAddedPayload$Type extends MessageType<MovementClaimAddedPaylo
*/
export const MovementClaimAddedPayload = new MovementClaimAddedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementClaimAddedEvent$Type extends MessageType<MovementClaimAddedEvent> {
constructor() {
super("api.MovementClaimAddedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => MovementClaimAddedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "ClaimAdded", "api.preAggMethods": "addClaim" });
}
create(value?: PartialMessage<MovementClaimAddedEvent>): MovementClaimAddedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementClaimAddedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementClaimAddedEvent): MovementClaimAddedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.MovementClaimAddedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = MovementClaimAddedPayload.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: MovementClaimAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementClaimAddedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
MovementClaimAddedPayload.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.MovementClaimAddedEvent
*/
export const MovementClaimAddedEvent = new MovementClaimAddedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementClaimAddedRequest$Type extends MessageType<MovementClaimAddedRequest> {
constructor() {
super("api.MovementClaimAddedRequest", [
@@ -1468,66 +1106,6 @@ class MovementAttachmentAddedPayload$Type extends MessageType<MovementAttachment
*/
export const MovementAttachmentAddedPayload = new MovementAttachmentAddedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementAttachmentAddedEvent$Type extends MessageType<MovementAttachmentAddedEvent> {
constructor() {
super("api.MovementAttachmentAddedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => MovementAttachmentAddedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentAdded" });
}
create(value?: PartialMessage<MovementAttachmentAddedEvent>): MovementAttachmentAddedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementAttachmentAddedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementAttachmentAddedEvent): MovementAttachmentAddedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.MovementAttachmentAddedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = MovementAttachmentAddedPayload.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: MovementAttachmentAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementAttachmentAddedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
MovementAttachmentAddedPayload.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.MovementAttachmentAddedEvent
*/
export const MovementAttachmentAddedEvent = new MovementAttachmentAddedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementAttachmentAddedRequest$Type extends MessageType<MovementAttachmentAddedRequest> {
constructor() {
super("api.MovementAttachmentAddedRequest", [
@@ -1688,66 +1266,6 @@ class MovementAttachmentRemovedPayload$Type extends MessageType<MovementAttachme
*/
export const MovementAttachmentRemovedPayload = new MovementAttachmentRemovedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementAttachmentRemovedEvent$Type extends MessageType<MovementAttachmentRemovedEvent> {
constructor() {
super("api.MovementAttachmentRemovedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => MovementAttachmentRemovedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentRemoved" });
}
create(value?: PartialMessage<MovementAttachmentRemovedEvent>): MovementAttachmentRemovedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementAttachmentRemovedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementAttachmentRemovedEvent): MovementAttachmentRemovedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.MovementAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = MovementAttachmentRemovedPayload.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: MovementAttachmentRemovedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementAttachmentRemovedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
MovementAttachmentRemovedPayload.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.MovementAttachmentRemovedEvent
*/
export const MovementAttachmentRemovedEvent = new MovementAttachmentRemovedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementAttachmentRemovedRequest$Type extends MessageType<MovementAttachmentRemovedRequest> {
constructor() {
super("api.MovementAttachmentRemovedRequest", [
@@ -1899,66 +1417,6 @@ class MovementDeletedPayload$Type extends MessageType<MovementDeletedPayload> {
*/
export const MovementDeletedPayload = new MovementDeletedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementDeletedEvent$Type extends MessageType<MovementDeletedEvent> {
constructor() {
super("api.MovementDeletedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => MovementDeletedPayload }
], { "api.messageType": "Event", "api.inputEvent": "Deleted" });
}
create(value?: PartialMessage<MovementDeletedEvent>): MovementDeletedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementDeletedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementDeletedEvent): MovementDeletedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.MovementDeletedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = MovementDeletedPayload.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: MovementDeletedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementDeletedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
MovementDeletedPayload.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.MovementDeletedEvent
*/
export const MovementDeletedEvent = new MovementDeletedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementDeletedRequest$Type extends MessageType<MovementDeletedRequest> {
constructor() {
super("api.MovementDeletedRequest", [

82
notifInput.ts
View File

@@ -12,9 +12,8 @@ import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { ResponseHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { NotifTypeEnum } from "./collabShared";
//
// Aggregation object message
@@ -70,25 +69,6 @@ export interface NotifCreatedPayload {
*/
tags: string;
}
/**
* Event message
*
* @generated from protobuf message api.NotifCreatedEvent
*/
export interface NotifCreatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.NotifCreatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: NotifCreatedPayload;
}
/**
* API Request
*
@@ -227,66 +207,6 @@ class NotifCreatedPayload$Type extends MessageType<NotifCreatedPayload> {
*/
export const NotifCreatedPayload = new NotifCreatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class NotifCreatedEvent$Type extends MessageType<NotifCreatedEvent> {
constructor() {
super("api.NotifCreatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => NotifCreatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "EntityID", "Payload"] } }, "api.messageType": "Event", "api.inputEvent": "Created" });
}
create(value?: PartialMessage<NotifCreatedEvent>): NotifCreatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<NotifCreatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NotifCreatedEvent): NotifCreatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.NotifCreatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = NotifCreatedPayload.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: NotifCreatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.NotifCreatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
NotifCreatedPayload.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.NotifCreatedEvent
*/
export const NotifCreatedEvent = new NotifCreatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class NotifCreatedRequest$Type extends MessageType<NotifCreatedRequest> {
constructor() {
super("api.NotifCreatedRequest", [

1277
orderInput.ts
View File

File diff suppressed because it is too large Load Diff

2
package.json
View File

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

40
partnerInput.client.ts
View File

@@ -24,6 +24,8 @@ import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
// option (payload) = true;
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
//
// repeated ClaimSummary Claims = 1
// [
// (aggKey) = "ClaimTypeID",
@@ -31,24 +33,6 @@ import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
// description: "Number of claims added per type"}
// ];
// }
// message PartnerClaimAddedEvent
// {
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
// EventHeader Header = 1
// [
// (validate.rules).message.required = true
// ];
// EntityID ID = 2
// [
// (validate.rules).message.required = true
// ];
// PartnerClaimAddedPayload Payload = 3
// [
// (validate.rules).message.required = true
// ];
// }
// message PartnerClaimAddedRequest {
// option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema) = {
// json_schema: {
@@ -110,6 +94,8 @@ export interface IPartnerInputAPIClient {
// option (payload) = true;
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
//
// repeated ClaimSummary Claims = 1
// [
// (aggKey) = "ClaimTypeID",
@@ -117,24 +103,6 @@ export interface IPartnerInputAPIClient {
// description: "Number of claims added per type"}
// ];
// }
// message PartnerClaimAddedEvent
// {
// option (inputEvent) = "ClaimAdded";
// option (messageType) = "Event";
// option (preAggMethods) = "addClaim"; // Here are listed the pre aggregation methods to call before event message is aggregated
// EventHeader Header = 1
// [
// (validate.rules).message.required = true
// ];
// EntityID ID = 2
// [
// (validate.rules).message.required = true
// ];
// PartnerClaimAddedPayload Payload = 3
// [
// (validate.rules).message.required = true
// ];
// }
// message PartnerClaimAddedRequest {
// option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema) = {
// json_schema: {

319
partnerInput.ts
View File

@@ -13,9 +13,8 @@ import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { AttachmentSummary } from "./shared";
import { ResponseHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { Address } from "./repositoryShared";
// Event Payload
@@ -50,25 +49,6 @@ export interface PartnerCreatedPayload {
*/
allowedRoles: string[];
}
/**
* Event message
*
* @generated from protobuf message api.PartnerCreatedEvent
*/
export interface PartnerCreatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.PartnerCreatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: PartnerCreatedPayload;
}
/**
* API Request
*
@@ -110,25 +90,6 @@ export interface PartnerCreatedResponse {
*/
export interface PartnerDeletedPayload {
}
/**
* Event message
*
* @generated from protobuf message api.PartnerDeletedEvent
*/
export interface PartnerDeletedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.PartnerDeletedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: PartnerDeletedPayload;
}
/**
* API Request
*
@@ -175,23 +136,6 @@ export interface PartnerAttachmentAddedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.PartnerAttachmentAddedEvent
*/
export interface PartnerAttachmentAddedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.PartnerAttachmentAddedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: PartnerAttachmentAddedPayload;
}
/**
* @generated from protobuf message api.PartnerAttachmentAddedRequest
*/
@@ -234,23 +178,6 @@ export interface PartnerAttachmentRemovedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.PartnerAttachmentRemovedEvent
*/
export interface PartnerAttachmentRemovedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.PartnerAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: PartnerAttachmentRemovedPayload;
}
/**
* @generated from protobuf message api.PartnerAttachmentRemovedRequest
*/
@@ -360,66 +287,6 @@ class PartnerCreatedPayload$Type extends MessageType<PartnerCreatedPayload> {
*/
export const PartnerCreatedPayload = new PartnerCreatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerCreatedEvent$Type extends MessageType<PartnerCreatedEvent> {
constructor() {
super("api.PartnerCreatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => PartnerCreatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Created" });
}
create(value?: PartialMessage<PartnerCreatedEvent>): PartnerCreatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerCreatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerCreatedEvent): PartnerCreatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.PartnerCreatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = PartnerCreatedPayload.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: PartnerCreatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.PartnerCreatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
PartnerCreatedPayload.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.PartnerCreatedEvent
*/
export const PartnerCreatedEvent = new PartnerCreatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerCreatedRequest$Type extends MessageType<PartnerCreatedRequest> {
constructor() {
super("api.PartnerCreatedRequest", [
@@ -571,66 +438,6 @@ class PartnerDeletedPayload$Type extends MessageType<PartnerDeletedPayload> {
*/
export const PartnerDeletedPayload = new PartnerDeletedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerDeletedEvent$Type extends MessageType<PartnerDeletedEvent> {
constructor() {
super("api.PartnerDeletedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => PartnerDeletedPayload }
], { "api.messageType": "Event", "api.inputEvent": "Deleted" });
}
create(value?: PartialMessage<PartnerDeletedEvent>): PartnerDeletedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerDeletedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerDeletedEvent): PartnerDeletedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.PartnerDeletedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = PartnerDeletedPayload.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: PartnerDeletedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.PartnerDeletedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
PartnerDeletedPayload.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.PartnerDeletedEvent
*/
export const PartnerDeletedEvent = new PartnerDeletedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerDeletedRequest$Type extends MessageType<PartnerDeletedRequest> {
constructor() {
super("api.PartnerDeletedRequest", [
@@ -748,7 +555,7 @@ class PartnerAttachmentAddedPayload$Type extends MessageType<PartnerAttachmentAd
constructor() {
super("api.PartnerAttachmentAddedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments added per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<PartnerAttachmentAddedPayload>): PartnerAttachmentAddedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -791,66 +598,6 @@ class PartnerAttachmentAddedPayload$Type extends MessageType<PartnerAttachmentAd
*/
export const PartnerAttachmentAddedPayload = new PartnerAttachmentAddedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerAttachmentAddedEvent$Type extends MessageType<PartnerAttachmentAddedEvent> {
constructor() {
super("api.PartnerAttachmentAddedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => PartnerAttachmentAddedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<PartnerAttachmentAddedEvent>): PartnerAttachmentAddedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerAttachmentAddedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerAttachmentAddedEvent): PartnerAttachmentAddedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.PartnerAttachmentAddedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = PartnerAttachmentAddedPayload.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: PartnerAttachmentAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.PartnerAttachmentAddedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
PartnerAttachmentAddedPayload.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.PartnerAttachmentAddedEvent
*/
export const PartnerAttachmentAddedEvent = new PartnerAttachmentAddedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerAttachmentAddedRequest$Type extends MessageType<PartnerAttachmentAddedRequest> {
constructor() {
super("api.PartnerAttachmentAddedRequest", [
@@ -968,7 +715,7 @@ class PartnerAttachmentRemovedPayload$Type extends MessageType<PartnerAttachment
constructor() {
super("api.PartnerAttachmentRemovedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments removed per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<PartnerAttachmentRemovedPayload>): PartnerAttachmentRemovedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1011,66 +758,6 @@ class PartnerAttachmentRemovedPayload$Type extends MessageType<PartnerAttachment
*/
export const PartnerAttachmentRemovedPayload = new PartnerAttachmentRemovedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerAttachmentRemovedEvent$Type extends MessageType<PartnerAttachmentRemovedEvent> {
constructor() {
super("api.PartnerAttachmentRemovedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => PartnerAttachmentRemovedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<PartnerAttachmentRemovedEvent>): PartnerAttachmentRemovedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerAttachmentRemovedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerAttachmentRemovedEvent): PartnerAttachmentRemovedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.PartnerAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = PartnerAttachmentRemovedPayload.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: PartnerAttachmentRemovedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.PartnerAttachmentRemovedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
PartnerAttachmentRemovedPayload.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.PartnerAttachmentRemovedEvent
*/
export const PartnerAttachmentRemovedEvent = new PartnerAttachmentRemovedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerAttachmentRemovedRequest$Type extends MessageType<PartnerAttachmentRemovedRequest> {
constructor() {
super("api.PartnerAttachmentRemovedRequest", [

66
shared.ts
View File

@@ -412,6 +412,19 @@ export interface GenericObject {
*/
export interface GenericObjectPayload {
}
/**
* @generated from protobuf message api.EntityEventResponse
*/
export interface EntityEventResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1 [json_name = "Header"];
*/
header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
}
/**
* Common structures
*
@@ -3494,6 +3507,59 @@ class GenericObjectPayload$Type extends MessageType<GenericObjectPayload> {
*/
export const GenericObjectPayload = new GenericObjectPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class EntityEventResponse$Type extends MessageType<EntityEventResponse> {
constructor() {
super("api.EntityEventResponse", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID }
]);
}
create(value?: PartialMessage<EntityEventResponse>): EntityEventResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<EntityEventResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EntityEventResponse): EntityEventResponse {
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 [json_name = "Header"];*/ 1:
message.header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "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: EntityEventResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1 [json_name = "Header"]; */
if (message.header)
ResponseHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
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.EntityEventResponse
*/
export const EntityEventResponse = new EntityEventResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class DateTime$Type extends MessageType<DateTime> {
constructor() {
super("api.DateTime", [

234
stockInput.ts
View File

@@ -12,11 +12,10 @@ import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { StockSnapshot } from "./warehousingShared";
import { EntityID } from "./shared";
import { ResponseHeader } from "./shared";
import { NoID } from "./shared";
import { RequestProjectHeader } from "./shared";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
import { StockMovement } from "./warehousingShared";
import { ActorPayload } from "./actor";
import { EnrichedGoods } from "./warehousingShared";
@@ -53,23 +52,6 @@ export interface StockMovedPayload {
*/
movement?: StockMovement;
}
/**
* @generated from protobuf message api.StockMovedEvent
*/
export interface StockMovedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.StockMovedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: StockMovedPayload;
}
/**
* @generated from protobuf message api.StockMovedRequest
*/
@@ -142,23 +124,6 @@ export interface StockSnapshottedPayload {
*/
snapshot?: StockSnapshot;
}
/**
* @generated from protobuf message api.StockSnapshottedEvent
*/
export interface StockSnapshottedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.StockSnapshottedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: StockSnapshottedPayload;
}
/**
* @generated from protobuf message api.StockSnapshottedRequest
*/
@@ -226,23 +191,6 @@ export interface StockDeletedPayload {
*/
actor?: ActorPayload;
}
/**
* @generated from protobuf message api.StockDeletedEvent
*/
export interface StockDeletedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.StockDeletedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: StockDeletedPayload;
}
/**
* @generated from protobuf message api.StockDeletedRequest
*/
@@ -350,66 +298,6 @@ class StockMovedPayload$Type extends MessageType<StockMovedPayload> {
*/
export const StockMovedPayload = new StockMovedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockMovedEvent$Type extends MessageType<StockMovedEvent> {
constructor() {
super("api.StockMovedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => StockMovedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Moved" });
}
create(value?: PartialMessage<StockMovedEvent>): StockMovedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<StockMovedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StockMovedEvent): StockMovedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.StockMovedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = StockMovedPayload.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: StockMovedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.StockMovedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
StockMovedPayload.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.StockMovedEvent
*/
export const StockMovedEvent = new StockMovedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockMovedRequest$Type extends MessageType<StockMovedRequest> {
constructor() {
super("api.StockMovedRequest", [
@@ -591,66 +479,6 @@ class StockSnapshottedPayload$Type extends MessageType<StockSnapshottedPayload>
*/
export const StockSnapshottedPayload = new StockSnapshottedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockSnapshottedEvent$Type extends MessageType<StockSnapshottedEvent> {
constructor() {
super("api.StockSnapshottedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => StockSnapshottedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Snapshotted" });
}
create(value?: PartialMessage<StockSnapshottedEvent>): StockSnapshottedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<StockSnapshottedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StockSnapshottedEvent): StockSnapshottedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.StockSnapshottedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = StockSnapshottedPayload.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: StockSnapshottedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.StockSnapshottedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
StockSnapshottedPayload.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.StockSnapshottedEvent
*/
export const StockSnapshottedEvent = new StockSnapshottedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockSnapshottedRequest$Type extends MessageType<StockSnapshottedRequest> {
constructor() {
super("api.StockSnapshottedRequest", [
@@ -825,66 +653,6 @@ class StockDeletedPayload$Type extends MessageType<StockDeletedPayload> {
*/
export const StockDeletedPayload = new StockDeletedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockDeletedEvent$Type extends MessageType<StockDeletedEvent> {
constructor() {
super("api.StockDeletedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => StockDeletedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Deleted" });
}
create(value?: PartialMessage<StockDeletedEvent>): StockDeletedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<StockDeletedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StockDeletedEvent): StockDeletedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.StockDeletedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = StockDeletedPayload.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: StockDeletedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.StockDeletedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
StockDeletedPayload.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.StockDeletedEvent
*/
export const StockDeletedEvent = new StockDeletedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockDeletedRequest$Type extends MessageType<StockDeletedRequest> {
constructor() {
super("api.StockDeletedRequest", [

633
trackingInput.ts
View File

@@ -16,9 +16,8 @@ import { ETA } from "./tradeShared";
import { TradeTier } from "./tradeShared";
import { DateTime } from "./shared";
import { ResponseHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
import { RequestProjectHeader } from "./shared";
import { TrackingEvent } from "./transportShared";
// Notified
@@ -37,23 +36,6 @@ export interface TrackingNotifiedPayload {
*/
events: TrackingEvent[];
}
/**
* @generated from protobuf message api.TrackingNotifiedEvent
*/
export interface TrackingNotifiedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingNotifiedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingNotifiedPayload;
}
/**
* @generated from protobuf message api.TrackingNotifiedRequest
*/
@@ -131,23 +113,6 @@ export interface TrackingDispatchedPayload {
*/
hUShipTo?: TradeTier;
}
/**
* @generated from protobuf message api.TrackingDispatchedEvent
*/
export interface TrackingDispatchedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingDispatchedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingDispatchedPayload;
}
/**
* @generated from protobuf message api.TrackingDispatchedRequest
*/
@@ -213,23 +178,6 @@ export interface TrackingHULabeledPayload {
*/
hUShipTo?: TradeTier;
}
/**
* @generated from protobuf message api.TrackingHULabeledEvent
*/
export interface TrackingHULabeledEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingHULabeledPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingHULabeledPayload;
}
/**
* @generated from protobuf message api.TrackingHULabeledRequest
*/
@@ -295,23 +243,6 @@ export interface TrackingSwitchedPayload {
*/
nextHUShipTo?: TradeTier;
}
/**
* @generated from protobuf message api.TrackingSwitchedEvent
*/
export interface TrackingSwitchedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingSwitchedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingSwitchedPayload;
}
/**
* @generated from protobuf message api.TrackingSwitchedRequest
*/
@@ -356,23 +287,6 @@ export interface TrackingETAUpdatedPayload {
*/
trackingETA?: ETA;
}
/**
* @generated from protobuf message api.TrackingETAUpdatedEvent
*/
export interface TrackingETAUpdatedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingETAUpdatedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingETAUpdatedPayload;
}
/**
* @generated from protobuf message api.TrackingETAUpdatedRequest
*/
@@ -415,23 +329,6 @@ export interface TrackingAttachmentAddedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.TrackingAttachmentAddedEvent
*/
export interface TrackingAttachmentAddedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingAttachmentAddedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingAttachmentAddedPayload;
}
/**
* @generated from protobuf message api.TrackingAttachmentAddedRequest
*/
@@ -474,23 +371,6 @@ export interface TrackingAttachmentRemovedPayload {
*/
attachments: AttachmentSummary[];
}
/**
* @generated from protobuf message api.TrackingAttachmentRemovedEvent
*/
export interface TrackingAttachmentRemovedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingAttachmentRemovedPayload;
}
/**
* @generated from protobuf message api.TrackingAttachmentRemovedRequest
*/
@@ -528,25 +408,6 @@ export interface TrackingAttachmentRemovedResponse {
*/
export interface TrackingDeletedPayload {
}
/**
* Event message
*
* @generated from protobuf message api.TrackingDeletedEvent
*/
export interface TrackingDeletedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1 [json_name = "Header"];
*/
header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.TrackingDeletedPayload Payload = 3 [json_name = "Payload"];
*/
payload?: TrackingDeletedPayload;
}
/**
* API Request
*
@@ -629,66 +490,6 @@ class TrackingNotifiedPayload$Type extends MessageType<TrackingNotifiedPayload>
*/
export const TrackingNotifiedPayload = new TrackingNotifiedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingNotifiedEvent$Type extends MessageType<TrackingNotifiedEvent> {
constructor() {
super("api.TrackingNotifiedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingNotifiedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Notified" });
}
create(value?: PartialMessage<TrackingNotifiedEvent>): TrackingNotifiedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingNotifiedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingNotifiedEvent): TrackingNotifiedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingNotifiedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingNotifiedPayload.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: TrackingNotifiedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingNotifiedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingNotifiedPayload.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.TrackingNotifiedEvent
*/
export const TrackingNotifiedEvent = new TrackingNotifiedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingNotifiedRequest$Type extends MessageType<TrackingNotifiedRequest> {
constructor() {
super("api.TrackingNotifiedRequest", [
@@ -811,7 +612,7 @@ class TrackingDispatchedPayload$Type extends MessageType<TrackingDispatchedPaylo
{ no: 6, name: "HUCarrier", kind: "message", jsonName: "HUCarrier", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "The carrier which tracks the Handling unit" } } },
{ no: 7, name: "HUShipFrom", kind: "message", jsonName: "HUShipFrom", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Where the Handling unit is shipped from" } } },
{ no: 8, name: "HUShipTo", kind: "message", jsonName: "HUShipTo", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Where the Handling unit is shipped to" } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["HandlingunitID", "DispatchedDateTime"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Dispatched" });
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["HandlingunitID", "DispatchedDateTime"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Dispatched", "api.preAggMethods": "verifyActorPartner" });
}
create(value?: PartialMessage<TrackingDispatchedPayload>): TrackingDispatchedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -885,66 +686,6 @@ class TrackingDispatchedPayload$Type extends MessageType<TrackingDispatchedPaylo
*/
export const TrackingDispatchedPayload = new TrackingDispatchedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingDispatchedEvent$Type extends MessageType<TrackingDispatchedEvent> {
constructor() {
super("api.TrackingDispatchedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingDispatchedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Dispatched", "api.preAggMethods": "verifyActorPartner" });
}
create(value?: PartialMessage<TrackingDispatchedEvent>): TrackingDispatchedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingDispatchedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingDispatchedEvent): TrackingDispatchedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingDispatchedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingDispatchedPayload.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: TrackingDispatchedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingDispatchedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingDispatchedPayload.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.TrackingDispatchedEvent
*/
export const TrackingDispatchedEvent = new TrackingDispatchedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingDispatchedRequest$Type extends MessageType<TrackingDispatchedRequest> {
constructor() {
super("api.TrackingDispatchedRequest", [
@@ -1066,7 +807,7 @@ class TrackingHULabeledPayload$Type extends MessageType<TrackingHULabeledPayload
{ no: 6, name: "HUCarrier", kind: "message", jsonName: "HUCarrier", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "The carrier which tracks the Handling unit" } } },
{ no: 7, name: "HUShipFrom", kind: "message", jsonName: "HUShipFrom", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Where the Handling unit is shipped from" } } },
{ no: 8, name: "HUShipTo", kind: "message", jsonName: "HUShipTo", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Where the Handling unit is shipped to" } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["HandlingunitID", "DispatchedDateTime"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "HULabeled" });
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["HandlingunitID", "DispatchedDateTime"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "HULabeled", "api.preAggMethods": "verifyActorPartner" });
}
create(value?: PartialMessage<TrackingHULabeledPayload>): TrackingHULabeledPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1134,66 +875,6 @@ class TrackingHULabeledPayload$Type extends MessageType<TrackingHULabeledPayload
*/
export const TrackingHULabeledPayload = new TrackingHULabeledPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingHULabeledEvent$Type extends MessageType<TrackingHULabeledEvent> {
constructor() {
super("api.TrackingHULabeledEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingHULabeledPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "HULabeled", "api.preAggMethods": "verifyActorPartner" });
}
create(value?: PartialMessage<TrackingHULabeledEvent>): TrackingHULabeledEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingHULabeledEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingHULabeledEvent): TrackingHULabeledEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingHULabeledPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingHULabeledPayload.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: TrackingHULabeledEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingHULabeledPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingHULabeledPayload.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.TrackingHULabeledEvent
*/
export const TrackingHULabeledEvent = new TrackingHULabeledEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingHULabeledRequest$Type extends MessageType<TrackingHULabeledRequest> {
constructor() {
super("api.TrackingHULabeledRequest", [
@@ -1315,7 +996,7 @@ class TrackingSwitchedPayload$Type extends MessageType<TrackingSwitchedPayload>
{ no: 3, name: "NextHUCarrier", kind: "message", jsonName: "NextHUCarrier", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "The new carrier which will track the Handling unit" } } },
{ no: 4, name: "NextHUShipFrom", kind: "message", jsonName: "NextHUShipFrom", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Where the Handling unit will be shipped from" } } },
{ no: 5, name: "NextHUShipTo", kind: "message", jsonName: "NextHUShipTo", T: () => TradeTier, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Where the Handling unit will be shipped to" } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["NextTrackingID"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Switched" });
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["NextTrackingID"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Switched", "api.preAggMethods": "verifyActorPartner" });
}
create(value?: PartialMessage<TrackingSwitchedPayload>): TrackingSwitchedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1383,66 +1064,6 @@ class TrackingSwitchedPayload$Type extends MessageType<TrackingSwitchedPayload>
*/
export const TrackingSwitchedPayload = new TrackingSwitchedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingSwitchedEvent$Type extends MessageType<TrackingSwitchedEvent> {
constructor() {
super("api.TrackingSwitchedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingSwitchedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["HandlingunitID", "DispatchedDateTime"] } }, "api.messageType": "Event", "api.inputEvent": "Switched", "api.preAggMethods": "verifyActorPartner" });
}
create(value?: PartialMessage<TrackingSwitchedEvent>): TrackingSwitchedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingSwitchedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingSwitchedEvent): TrackingSwitchedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingSwitchedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingSwitchedPayload.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: TrackingSwitchedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingSwitchedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingSwitchedPayload.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.TrackingSwitchedEvent
*/
export const TrackingSwitchedEvent = new TrackingSwitchedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingSwitchedRequest$Type extends MessageType<TrackingSwitchedRequest> {
constructor() {
super("api.TrackingSwitchedRequest", [
@@ -1560,7 +1181,7 @@ class TrackingETAUpdatedPayload$Type extends MessageType<TrackingETAUpdatedPaylo
constructor() {
super("api.TrackingETAUpdatedPayload", [
{ no: 1, name: "TrackingETA", kind: "message", jsonName: "TrackingETA", T: () => ETA, options: { "validate.rules": { message: { required: true } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "The ETA for the tracked HU" } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["TrackingETA"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "ETAUpdated" });
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["TrackingETA"] } }, "api.messageType": "Event", "api.payload": true, "api.inputEvent": "ETAUpdated", "api.preAggMethods": "setETAActualDate" });
}
create(value?: PartialMessage<TrackingETAUpdatedPayload>): TrackingETAUpdatedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1602,66 +1223,6 @@ class TrackingETAUpdatedPayload$Type extends MessageType<TrackingETAUpdatedPaylo
*/
export const TrackingETAUpdatedPayload = new TrackingETAUpdatedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingETAUpdatedEvent$Type extends MessageType<TrackingETAUpdatedEvent> {
constructor() {
super("api.TrackingETAUpdatedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingETAUpdatedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["TrackingETA"] } }, "api.messageType": "Event", "api.inputEvent": "ETAUpdated", "api.preAggMethods": "setETAActualDate" });
}
create(value?: PartialMessage<TrackingETAUpdatedEvent>): TrackingETAUpdatedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingETAUpdatedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingETAUpdatedEvent): TrackingETAUpdatedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingETAUpdatedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingETAUpdatedPayload.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: TrackingETAUpdatedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingETAUpdatedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingETAUpdatedPayload.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.TrackingETAUpdatedEvent
*/
export const TrackingETAUpdatedEvent = new TrackingETAUpdatedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingETAUpdatedRequest$Type extends MessageType<TrackingETAUpdatedRequest> {
constructor() {
super("api.TrackingETAUpdatedRequest", [
@@ -1779,7 +1340,7 @@ class TrackingAttachmentAddedPayload$Type extends MessageType<TrackingAttachment
constructor() {
super("api.TrackingAttachmentAddedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments added per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<TrackingAttachmentAddedPayload>): TrackingAttachmentAddedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -1822,66 +1383,6 @@ class TrackingAttachmentAddedPayload$Type extends MessageType<TrackingAttachment
*/
export const TrackingAttachmentAddedPayload = new TrackingAttachmentAddedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingAttachmentAddedEvent$Type extends MessageType<TrackingAttachmentAddedEvent> {
constructor() {
super("api.TrackingAttachmentAddedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingAttachmentAddedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentAdded", "api.preAggMethods": "addAttachment" });
}
create(value?: PartialMessage<TrackingAttachmentAddedEvent>): TrackingAttachmentAddedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingAttachmentAddedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingAttachmentAddedEvent): TrackingAttachmentAddedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingAttachmentAddedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingAttachmentAddedPayload.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: TrackingAttachmentAddedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingAttachmentAddedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingAttachmentAddedPayload.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.TrackingAttachmentAddedEvent
*/
export const TrackingAttachmentAddedEvent = new TrackingAttachmentAddedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingAttachmentAddedRequest$Type extends MessageType<TrackingAttachmentAddedRequest> {
constructor() {
super("api.TrackingAttachmentAddedRequest", [
@@ -1999,7 +1500,7 @@ class TrackingAttachmentRemovedPayload$Type extends MessageType<TrackingAttachme
constructor() {
super("api.TrackingAttachmentRemovedPayload", [
{ no: 1, name: "Attachments", kind: "message", jsonName: "Attachments", repeat: 1 /*RepeatType.PACKED*/, T: () => AttachmentSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of attachments removed per type" } } }
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved" });
], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<TrackingAttachmentRemovedPayload>): TrackingAttachmentRemovedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
@@ -2042,66 +1543,6 @@ class TrackingAttachmentRemovedPayload$Type extends MessageType<TrackingAttachme
*/
export const TrackingAttachmentRemovedPayload = new TrackingAttachmentRemovedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingAttachmentRemovedEvent$Type extends MessageType<TrackingAttachmentRemovedEvent> {
constructor() {
super("api.TrackingAttachmentRemovedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingAttachmentRemovedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "AttachmentRemoved", "api.preAggMethods": "removeAttachment" });
}
create(value?: PartialMessage<TrackingAttachmentRemovedEvent>): TrackingAttachmentRemovedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingAttachmentRemovedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingAttachmentRemovedEvent): TrackingAttachmentRemovedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingAttachmentRemovedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingAttachmentRemovedPayload.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: TrackingAttachmentRemovedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingAttachmentRemovedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingAttachmentRemovedPayload.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.TrackingAttachmentRemovedEvent
*/
export const TrackingAttachmentRemovedEvent = new TrackingAttachmentRemovedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingAttachmentRemovedRequest$Type extends MessageType<TrackingAttachmentRemovedRequest> {
constructor() {
super("api.TrackingAttachmentRemovedRequest", [
@@ -2253,66 +1694,6 @@ class TrackingDeletedPayload$Type extends MessageType<TrackingDeletedPayload> {
*/
export const TrackingDeletedPayload = new TrackingDeletedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingDeletedEvent$Type extends MessageType<TrackingDeletedEvent> {
constructor() {
super("api.TrackingDeletedEvent", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => TrackingDeletedPayload }
], { "api.messageType": "Event", "api.inputEvent": "Deleted" });
}
create(value?: PartialMessage<TrackingDeletedEvent>): TrackingDeletedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingDeletedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingDeletedEvent): TrackingDeletedEvent {
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 [json_name = "Header"];*/ 1:
message.header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.TrackingDeletedPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = TrackingDeletedPayload.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: TrackingDeletedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1 [json_name = "Header"]; */
if (message.header)
EventHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingDeletedPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
TrackingDeletedPayload.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.TrackingDeletedEvent
*/
export const TrackingDeletedEvent = new TrackingDeletedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingDeletedRequest$Type extends MessageType<TrackingDeletedRequest> {
constructor() {
super("api.TrackingDeletedRequest", [