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-11-06 14:45:09 +00:00
parent a9fd063301
commit 749fcbf86a
25 changed files with 3337 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
actorInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { ActorInputAPI } from "./actorInput";
import type { ActorSanitisedResponse } from "./actorInput";
import type { ActorSanitisedRequest } from "./actorInput";
import type { ActorAppointmentConfigurationUpdatedResponse } from "./actorInput";
import type { ActorAppointmentConfigurationUpdatedRequest } from "./actorInput";
import type { ActorMetaDataUpdatedResponse } from "./actorInput";
@@ -69,6 +71,10 @@ export interface IActorInputAPIClient {
* @generated from protobuf rpc: AppointmentConfigurationUpdated
*/
appointmentConfigurationUpdated(input: ActorAppointmentConfigurationUpdatedRequest, options?: RpcOptions): UnaryCall<ActorAppointmentConfigurationUpdatedRequest, ActorAppointmentConfigurationUpdatedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ActorSanitisedRequest, options?: RpcOptions): UnaryCall<ActorSanitisedRequest, ActorSanitisedResponse>;
}
/**
*
@@ -146,4 +152,11 @@ export class ActorInputAPIClient implements IActorInputAPIClient, ServiceInfo {
const method = this.methods[8], opt = this._transport.mergeOptions(options);
return stackIntercept<ActorAppointmentConfigurationUpdatedRequest, ActorAppointmentConfigurationUpdatedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ActorSanitisedRequest, options?: RpcOptions): UnaryCall<ActorSanitisedRequest, ActorSanitisedResponse> {
const method = this.methods[9], opt = this._transport.mergeOptions(options);
return stackIntercept<ActorSanitisedRequest, ActorSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
actorInput.ts
View File

@@ -723,6 +723,58 @@ export interface ActorAppointmentConfigurationUpdatedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.ActorSanitisedPayload
*/
export interface ActorSanitisedPayload {
}
/**
* @generated from protobuf message api.ActorSanitisedEvent
*/
export interface ActorSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ActorSanitisedPayload Payload = 3
*/
Payload?: ActorSanitisedPayload;
}
/**
* @generated from protobuf message api.ActorSanitisedRequest
*/
export interface ActorSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ActorSanitisedPayload Payload = 3
*/
Payload?: ActorSanitisedPayload;
}
/**
* @generated from protobuf message api.ActorSanitisedResponse
*/
export interface ActorSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class ActorCreatedPayload$Type extends MessageType<ActorCreatedPayload> {
constructor() {
@@ -2915,6 +2967,217 @@ class ActorAppointmentConfigurationUpdatedResponse$Type extends MessageType<Acto
* @generated MessageType for protobuf message api.ActorAppointmentConfigurationUpdatedResponse
*/
export const ActorAppointmentConfigurationUpdatedResponse = new ActorAppointmentConfigurationUpdatedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorSanitisedPayload$Type extends MessageType<ActorSanitisedPayload> {
constructor() {
super("api.ActorSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ActorSanitisedPayload>): ActorSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorSanitisedPayload): ActorSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ActorSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ActorSanitisedPayload
*/
export const ActorSanitisedPayload = new ActorSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorSanitisedEvent$Type extends MessageType<ActorSanitisedEvent> {
constructor() {
super("api.ActorSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ActorSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<ActorSanitisedEvent>): ActorSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorSanitisedEvent): ActorSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ActorSanitisedPayload Payload */ 3:
message.Payload = ActorSanitisedPayload.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: ActorSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorSanitisedPayload Payload = 3; */
if (message.Payload)
ActorSanitisedPayload.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.ActorSanitisedEvent
*/
export const ActorSanitisedEvent = new ActorSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorSanitisedRequest$Type extends MessageType<ActorSanitisedRequest> {
constructor() {
super("api.ActorSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ActorSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ActorSanitisedRequest>): ActorSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorSanitisedRequest): ActorSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ActorSanitisedPayload Payload */ 3:
message.Payload = ActorSanitisedPayload.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: ActorSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ActorSanitisedPayload Payload = 3; */
if (message.Payload)
ActorSanitisedPayload.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.ActorSanitisedRequest
*/
export const ActorSanitisedRequest = new ActorSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ActorSanitisedResponse$Type extends MessageType<ActorSanitisedResponse> {
constructor() {
super("api.ActorSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ActorSanitisedResponse>): ActorSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ActorSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorSanitisedResponse): ActorSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ActorSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ActorSanitisedResponse
*/
export const ActorSanitisedResponse = new ActorSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.ActorInputAPI
*/
@@ -2927,5 +3190,6 @@ export const ActorInputAPI = new ServiceType("api.ActorInputAPI", [
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "An attachment is removed for the Actor." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ActorAttachmentRemovedRequest, O: ActorAttachmentRemovedResponse },
{ name: "ClaimAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "A claim is added for the Actor." }, "api.rscType": "Project", "api.roles": "Platform.Project-Claim", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ActorClaimAddedRequest, O: ActorClaimAddedResponse },
{ name: "MetaDataUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "Some metadata have been updated on an Actor. This is typically called from OMS or ERP." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorMetaDataUpdatedRequest, O: ActorMetaDataUpdatedResponse },
{ name: "AppointmentConfigurationUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "Appointment configuration is updated on an Actor." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorAppointmentConfigurationUpdatedRequest, O: ActorAppointmentConfigurationUpdatedResponse }
{ name: "AppointmentConfigurationUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "Appointment configuration is updated on an Actor." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ActorAppointmentConfigurationUpdatedRequest, O: ActorAppointmentConfigurationUpdatedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Actor Inputs"], description: "An Actor has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ActorSanitisedRequest, O: ActorSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

13
appointmentInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { AppointmentInputAPI } from "./appointmentInput";
import type { AppointmentSanitisedResponse } from "./appointmentInput";
import type { AppointmentSanitisedRequest } from "./appointmentInput";
import type { AppointmentEmailsRemovedResponse } from "./appointmentInput";
import type { AppointmentEmailsRemovedRequest } from "./appointmentInput";
import type { AppointmentEmailsAddedResponse } from "./appointmentInput";
@@ -116,6 +118,10 @@ export interface IAppointmentInputAPIClient {
* @generated from protobuf rpc: EmailsRemoved
*/
emailsRemoved(input: AppointmentEmailsRemovedRequest, options?: RpcOptions): UnaryCall<AppointmentEmailsRemovedRequest, AppointmentEmailsRemovedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: AppointmentSanitisedRequest, options?: RpcOptions): UnaryCall<AppointmentSanitisedRequest, AppointmentSanitisedResponse>;
}
/**
*
@@ -248,4 +254,11 @@ export class AppointmentInputAPIClient implements IAppointmentInputAPIClient, Se
const method = this.methods[16], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentEmailsRemovedRequest, AppointmentEmailsRemovedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: AppointmentSanitisedRequest, options?: RpcOptions): UnaryCall<AppointmentSanitisedRequest, AppointmentSanitisedResponse> {
const method = this.methods[17], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentSanitisedRequest, AppointmentSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
appointmentInput.ts
View File

@@ -1178,6 +1178,58 @@ export interface AppointmentEmailsRemovedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.AppointmentSanitisedPayload
*/
export interface AppointmentSanitisedPayload {
}
/**
* @generated from protobuf message api.AppointmentSanitisedEvent
*/
export interface AppointmentSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.AppointmentSanitisedPayload Payload = 3
*/
Payload?: AppointmentSanitisedPayload;
}
/**
* @generated from protobuf message api.AppointmentSanitisedRequest
*/
export interface AppointmentSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.AppointmentSanitisedPayload Payload = 3
*/
Payload?: AppointmentSanitisedPayload;
}
/**
* @generated from protobuf message api.AppointmentSanitisedResponse
*/
export interface AppointmentSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentCreatedPayload$Type extends MessageType<AppointmentCreatedPayload> {
constructor() {
@@ -4932,6 +4984,217 @@ class AppointmentEmailsRemovedResponse$Type extends MessageType<AppointmentEmail
* @generated MessageType for protobuf message api.AppointmentEmailsRemovedResponse
*/
export const AppointmentEmailsRemovedResponse = new AppointmentEmailsRemovedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentSanitisedPayload$Type extends MessageType<AppointmentSanitisedPayload> {
constructor() {
super("api.AppointmentSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<AppointmentSanitisedPayload>): AppointmentSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<AppointmentSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentSanitisedPayload): AppointmentSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: AppointmentSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.AppointmentSanitisedPayload
*/
export const AppointmentSanitisedPayload = new AppointmentSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentSanitisedEvent$Type extends MessageType<AppointmentSanitisedEvent> {
constructor() {
super("api.AppointmentSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => AppointmentSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<AppointmentSanitisedEvent>): AppointmentSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<AppointmentSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentSanitisedEvent): AppointmentSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.AppointmentSanitisedPayload Payload */ 3:
message.Payload = AppointmentSanitisedPayload.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: AppointmentSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.AppointmentSanitisedPayload Payload = 3; */
if (message.Payload)
AppointmentSanitisedPayload.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.AppointmentSanitisedEvent
*/
export const AppointmentSanitisedEvent = new AppointmentSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentSanitisedRequest$Type extends MessageType<AppointmentSanitisedRequest> {
constructor() {
super("api.AppointmentSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => AppointmentSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<AppointmentSanitisedRequest>): AppointmentSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<AppointmentSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentSanitisedRequest): AppointmentSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.AppointmentSanitisedPayload Payload */ 3:
message.Payload = AppointmentSanitisedPayload.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: AppointmentSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.AppointmentSanitisedPayload Payload = 3; */
if (message.Payload)
AppointmentSanitisedPayload.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.AppointmentSanitisedRequest
*/
export const AppointmentSanitisedRequest = new AppointmentSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentSanitisedResponse$Type extends MessageType<AppointmentSanitisedResponse> {
constructor() {
super("api.AppointmentSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<AppointmentSanitisedResponse>): AppointmentSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<AppointmentSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentSanitisedResponse): AppointmentSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: AppointmentSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.AppointmentSanitisedResponse
*/
export const AppointmentSanitisedResponse = new AppointmentSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.AppointmentInputAPI
*/
@@ -4952,5 +5215,6 @@ export const AppointmentInputAPI = new ServiceType("api.AppointmentInputAPI", [
{ name: "AttachmentAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Inputs"], description: "An attachment is added for the Appointment." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: AppointmentAttachmentAddedRequest, O: AppointmentAttachmentAddedResponse },
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Inputs"], description: "An attachment is removed for the Appointment." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: AppointmentAttachmentRemovedRequest, O: AppointmentAttachmentRemovedResponse },
{ name: "EmailsAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Inputs"], description: "An appointment Emails have been added." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: AppointmentEmailsAddedRequest, O: AppointmentEmailsAddedResponse },
{ name: "EmailsRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Inputs"], description: "An appointment Emails have been removed." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: AppointmentEmailsRemovedRequest, O: AppointmentEmailsRemovedResponse }
{ name: "EmailsRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Inputs"], description: "An appointment Emails have been removed." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: AppointmentEmailsRemovedRequest, O: AppointmentEmailsRemovedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Inputs"], description: "An Appointment has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: AppointmentSanitisedRequest, O: AppointmentSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "collab-api-server" });

13
claimInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { ClaimInputAPI } from "./claimInput";
import type { ClaimSanitisedResponse } from "./claimInput";
import type { ClaimSanitisedRequest } from "./claimInput";
import type { ClaimDeletedResponse } from "./claimInput";
import type { ClaimDeletedRequest } from "./claimInput";
import type { ClaimMessageSentResponse } from "./claimInput";
@@ -92,6 +94,10 @@ export interface IClaimInputAPIClient {
* @generated from protobuf rpc: Deleted
*/
deleted(input: ClaimDeletedRequest, options?: RpcOptions): UnaryCall<ClaimDeletedRequest, ClaimDeletedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ClaimSanitisedRequest, options?: RpcOptions): UnaryCall<ClaimSanitisedRequest, ClaimSanitisedResponse>;
}
/**
*
@@ -196,4 +202,11 @@ export class ClaimInputAPIClient implements IClaimInputAPIClient, ServiceInfo {
const method = this.methods[12], opt = this._transport.mergeOptions(options);
return stackIntercept<ClaimDeletedRequest, ClaimDeletedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ClaimSanitisedRequest, options?: RpcOptions): UnaryCall<ClaimSanitisedRequest, ClaimSanitisedResponse> {
const method = this.methods[13], opt = this._transport.mergeOptions(options);
return stackIntercept<ClaimSanitisedRequest, ClaimSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
claimInput.ts
View File

@@ -943,6 +943,58 @@ export interface ClaimDeletedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.ClaimSanitisedPayload
*/
export interface ClaimSanitisedPayload {
}
/**
* @generated from protobuf message api.ClaimSanitisedEvent
*/
export interface ClaimSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ClaimSanitisedPayload Payload = 3
*/
Payload?: ClaimSanitisedPayload;
}
/**
* @generated from protobuf message api.ClaimSanitisedRequest
*/
export interface ClaimSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ClaimSanitisedPayload Payload = 3
*/
Payload?: ClaimSanitisedPayload;
}
/**
* @generated from protobuf message api.ClaimSanitisedResponse
*/
export interface ClaimSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class ClaimCreatedPayload$Type extends MessageType<ClaimCreatedPayload> {
constructor() {
@@ -3863,6 +3915,217 @@ class ClaimDeletedResponse$Type extends MessageType<ClaimDeletedResponse> {
* @generated MessageType for protobuf message api.ClaimDeletedResponse
*/
export const ClaimDeletedResponse = new ClaimDeletedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ClaimSanitisedPayload$Type extends MessageType<ClaimSanitisedPayload> {
constructor() {
super("api.ClaimSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ClaimSanitisedPayload>): ClaimSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ClaimSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClaimSanitisedPayload): ClaimSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ClaimSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ClaimSanitisedPayload
*/
export const ClaimSanitisedPayload = new ClaimSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ClaimSanitisedEvent$Type extends MessageType<ClaimSanitisedEvent> {
constructor() {
super("api.ClaimSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ClaimSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<ClaimSanitisedEvent>): ClaimSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ClaimSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClaimSanitisedEvent): ClaimSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ClaimSanitisedPayload Payload */ 3:
message.Payload = ClaimSanitisedPayload.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: ClaimSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ClaimSanitisedPayload Payload = 3; */
if (message.Payload)
ClaimSanitisedPayload.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.ClaimSanitisedEvent
*/
export const ClaimSanitisedEvent = new ClaimSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ClaimSanitisedRequest$Type extends MessageType<ClaimSanitisedRequest> {
constructor() {
super("api.ClaimSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ClaimSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ClaimSanitisedRequest>): ClaimSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ClaimSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClaimSanitisedRequest): ClaimSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ClaimSanitisedPayload Payload */ 3:
message.Payload = ClaimSanitisedPayload.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: ClaimSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ClaimSanitisedPayload Payload = 3; */
if (message.Payload)
ClaimSanitisedPayload.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.ClaimSanitisedRequest
*/
export const ClaimSanitisedRequest = new ClaimSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ClaimSanitisedResponse$Type extends MessageType<ClaimSanitisedResponse> {
constructor() {
super("api.ClaimSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ClaimSanitisedResponse>): ClaimSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ClaimSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClaimSanitisedResponse): ClaimSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ClaimSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ClaimSanitisedResponse
*/
export const ClaimSanitisedResponse = new ClaimSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.ClaimInputAPI
*/
@@ -3879,5 +4142,6 @@ export const ClaimInputAPI = new ServiceType("api.ClaimInputAPI", [
{ name: "MetaDataUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Claim Inputs"], description: "Some metadata have been updated on a claim. This is typically called from ERP or WMS." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ClaimMetaDataUpdatedRequest, O: ClaimMetaDataUpdatedResponse },
{ name: "TitleUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Claim Inputs"], description: "The title is updated for the claim." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ClaimTitleUpdatedRequest, O: ClaimTitleUpdatedResponse },
{ name: "MessageSent", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Claim Inputs"], description: "A message is sent in the claim room." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.customInput": true, "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ClaimMessageSentRequest, O: ClaimMessageSentResponse },
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Claim Inputs"], description: "An Claim has been deleted. This is called from Reflex Platform Admin service to share the Organisation Claims." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ClaimDeletedRequest, O: ClaimDeletedResponse }
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Claim Inputs"], description: "An Claim has been deleted. This is called from Reflex Platform Admin service to share the Organisation Claims." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ClaimDeletedRequest, O: ClaimDeletedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Claim Inputs"], description: "A Claim has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ClaimSanitisedRequest, O: ClaimSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "collab-api-server" });

13
executionflowInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { ExecutionflowInputAPI } from "./executionflowInput";
import type { ExecutionflowSanitisedResponse } from "./executionflowInput";
import type { ExecutionflowSanitisedRequest } from "./executionflowInput";
import type { ExecutionflowRenotifiedResponse } from "./executionflowInput";
import type { ExecutionflowRenotifiedRequest } from "./executionflowInput";
import type { ExecutionflowLinesDetectedResponse } from "./executionflowInput";
@@ -200,6 +202,10 @@ export interface IExecutionflowInputAPIClient {
* @generated from protobuf rpc: Renotified
*/
renotified(input: ExecutionflowRenotifiedRequest, options?: RpcOptions): UnaryCall<ExecutionflowRenotifiedRequest, ExecutionflowRenotifiedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ExecutionflowSanitisedRequest, options?: RpcOptions): UnaryCall<ExecutionflowSanitisedRequest, ExecutionflowSanitisedResponse>;
}
/**
*
@@ -430,4 +436,11 @@ export class ExecutionflowInputAPIClient implements IExecutionflowInputAPIClient
const method = this.methods[30], opt = this._transport.mergeOptions(options);
return stackIntercept<ExecutionflowRenotifiedRequest, ExecutionflowRenotifiedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ExecutionflowSanitisedRequest, options?: RpcOptions): UnaryCall<ExecutionflowSanitisedRequest, ExecutionflowSanitisedResponse> {
const method = this.methods[31], opt = this._transport.mergeOptions(options);
return stackIntercept<ExecutionflowSanitisedRequest, ExecutionflowSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
executionflowInput.ts
View File

@@ -1964,6 +1964,58 @@ export interface ExecutionflowRenotifiedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.ExecutionflowSanitisedPayload
*/
export interface ExecutionflowSanitisedPayload {
}
/**
* @generated from protobuf message api.ExecutionflowSanitisedEvent
*/
export interface ExecutionflowSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ExecutionflowSanitisedPayload Payload = 3
*/
Payload?: ExecutionflowSanitisedPayload;
}
/**
* @generated from protobuf message api.ExecutionflowSanitisedRequest
*/
export interface ExecutionflowSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ExecutionflowSanitisedPayload Payload = 3
*/
Payload?: ExecutionflowSanitisedPayload;
}
/**
* @generated from protobuf message api.ExecutionflowSanitisedResponse
*/
export interface ExecutionflowSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class ExecutionflowCreatedPayload$Type extends MessageType<ExecutionflowCreatedPayload> {
constructor() {
@@ -8780,6 +8832,217 @@ class ExecutionflowRenotifiedResponse$Type extends MessageType<ExecutionflowReno
* @generated MessageType for protobuf message api.ExecutionflowRenotifiedResponse
*/
export const ExecutionflowRenotifiedResponse = new ExecutionflowRenotifiedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExecutionflowSanitisedPayload$Type extends MessageType<ExecutionflowSanitisedPayload> {
constructor() {
super("api.ExecutionflowSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ExecutionflowSanitisedPayload>): ExecutionflowSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ExecutionflowSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowSanitisedPayload): ExecutionflowSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ExecutionflowSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ExecutionflowSanitisedPayload
*/
export const ExecutionflowSanitisedPayload = new ExecutionflowSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExecutionflowSanitisedEvent$Type extends MessageType<ExecutionflowSanitisedEvent> {
constructor() {
super("api.ExecutionflowSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ExecutionflowSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<ExecutionflowSanitisedEvent>): ExecutionflowSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ExecutionflowSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowSanitisedEvent): ExecutionflowSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ExecutionflowSanitisedPayload Payload */ 3:
message.Payload = ExecutionflowSanitisedPayload.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: ExecutionflowSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ExecutionflowSanitisedPayload Payload = 3; */
if (message.Payload)
ExecutionflowSanitisedPayload.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.ExecutionflowSanitisedEvent
*/
export const ExecutionflowSanitisedEvent = new ExecutionflowSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExecutionflowSanitisedRequest$Type extends MessageType<ExecutionflowSanitisedRequest> {
constructor() {
super("api.ExecutionflowSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ExecutionflowSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ExecutionflowSanitisedRequest>): ExecutionflowSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ExecutionflowSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowSanitisedRequest): ExecutionflowSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ExecutionflowSanitisedPayload Payload */ 3:
message.Payload = ExecutionflowSanitisedPayload.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: ExecutionflowSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ExecutionflowSanitisedPayload Payload = 3; */
if (message.Payload)
ExecutionflowSanitisedPayload.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.ExecutionflowSanitisedRequest
*/
export const ExecutionflowSanitisedRequest = new ExecutionflowSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExecutionflowSanitisedResponse$Type extends MessageType<ExecutionflowSanitisedResponse> {
constructor() {
super("api.ExecutionflowSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ExecutionflowSanitisedResponse>): ExecutionflowSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ExecutionflowSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionflowSanitisedResponse): ExecutionflowSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ExecutionflowSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ExecutionflowSanitisedResponse
*/
export const ExecutionflowSanitisedResponse = new ExecutionflowSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.ExecutionflowInputAPI
*/
@@ -8814,5 +9077,6 @@ export const ExecutionflowInputAPI = new ServiceType("api.ExecutionflowInputAPI"
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "An executionflow has been deleted. This is called from Reflex Platform Admin service to share the Organisation executionflows." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExecutionflowDeletedRequest, O: ExecutionflowDeletedResponse },
{ name: "LinesAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "Some lines are added for the Executionflow." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExecutionflowLinesAddedRequest, O: ExecutionflowLinesAddedResponse },
{ name: "LinesDetected", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "Adding lines in the Order has been reported to an Executionflow. This is called internally." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ExecutionflowLinesDetectedRequest, O: ExecutionflowLinesDetectedResponse },
{ name: "Renotified", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "Re-notify the connected partnerApps." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExecutionflowRenotifiedRequest, O: ExecutionflowRenotifiedResponse }
{ name: "Renotified", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "Re-notify the connected partnerApps." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExecutionflowRenotifiedRequest, O: ExecutionflowRenotifiedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["ExecutionFlow Inputs"], description: "An Executionflow has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ExecutionflowSanitisedRequest, O: ExecutionflowSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

13
handlingunitInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { HandlingunitInputAPI } from "./handlingunitInput";
import type { HandlingunitSanitisedResponse } from "./handlingunitInput";
import type { HandlingunitSanitisedRequest } from "./handlingunitInput";
import type { HandlingunitDeletedResponse } from "./handlingunitInput";
import type { HandlingunitDeletedRequest } from "./handlingunitInput";
import type { HandlingunitReadyToBeCollectedResponse } from "./handlingunitInput";
@@ -98,6 +100,10 @@ export interface IHandlingunitInputAPIClient {
* @generated from protobuf rpc: Deleted
*/
deleted(input: HandlingunitDeletedRequest, options?: RpcOptions): UnaryCall<HandlingunitDeletedRequest, HandlingunitDeletedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: HandlingunitSanitisedRequest, options?: RpcOptions): UnaryCall<HandlingunitSanitisedRequest, HandlingunitSanitisedResponse>;
}
/**
*
@@ -209,4 +215,11 @@ export class HandlingunitInputAPIClient implements IHandlingunitInputAPIClient,
const method = this.methods[13], opt = this._transport.mergeOptions(options);
return stackIntercept<HandlingunitDeletedRequest, HandlingunitDeletedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: HandlingunitSanitisedRequest, options?: RpcOptions): UnaryCall<HandlingunitSanitisedRequest, HandlingunitSanitisedResponse> {
const method = this.methods[14], opt = this._transport.mergeOptions(options);
return stackIntercept<HandlingunitSanitisedRequest, HandlingunitSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
handlingunitInput.ts
View File

@@ -896,6 +896,58 @@ export interface HandlingunitDeletedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.HandlingunitSanitisedPayload
*/
export interface HandlingunitSanitisedPayload {
}
/**
* @generated from protobuf message api.HandlingunitSanitisedEvent
*/
export interface HandlingunitSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.HandlingunitSanitisedPayload Payload = 3
*/
Payload?: HandlingunitSanitisedPayload;
}
/**
* @generated from protobuf message api.HandlingunitSanitisedRequest
*/
export interface HandlingunitSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.HandlingunitSanitisedPayload Payload = 3
*/
Payload?: HandlingunitSanitisedPayload;
}
/**
* @generated from protobuf message api.HandlingunitSanitisedResponse
*/
export interface HandlingunitSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class HandlingunitGoodsPreparedPayload$Type extends MessageType<HandlingunitGoodsPreparedPayload> {
constructor() {
@@ -3991,6 +4043,217 @@ class HandlingunitDeletedResponse$Type extends MessageType<HandlingunitDeletedRe
* @generated MessageType for protobuf message api.HandlingunitDeletedResponse
*/
export const HandlingunitDeletedResponse = new HandlingunitDeletedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class HandlingunitSanitisedPayload$Type extends MessageType<HandlingunitSanitisedPayload> {
constructor() {
super("api.HandlingunitSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<HandlingunitSanitisedPayload>): HandlingunitSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<HandlingunitSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HandlingunitSanitisedPayload): HandlingunitSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: HandlingunitSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.HandlingunitSanitisedPayload
*/
export const HandlingunitSanitisedPayload = new HandlingunitSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class HandlingunitSanitisedEvent$Type extends MessageType<HandlingunitSanitisedEvent> {
constructor() {
super("api.HandlingunitSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => HandlingunitSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<HandlingunitSanitisedEvent>): HandlingunitSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<HandlingunitSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HandlingunitSanitisedEvent): HandlingunitSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.HandlingunitSanitisedPayload Payload */ 3:
message.Payload = HandlingunitSanitisedPayload.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: HandlingunitSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.HandlingunitSanitisedPayload Payload = 3; */
if (message.Payload)
HandlingunitSanitisedPayload.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.HandlingunitSanitisedEvent
*/
export const HandlingunitSanitisedEvent = new HandlingunitSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class HandlingunitSanitisedRequest$Type extends MessageType<HandlingunitSanitisedRequest> {
constructor() {
super("api.HandlingunitSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => HandlingunitSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<HandlingunitSanitisedRequest>): HandlingunitSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<HandlingunitSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HandlingunitSanitisedRequest): HandlingunitSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.HandlingunitSanitisedPayload Payload */ 3:
message.Payload = HandlingunitSanitisedPayload.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: HandlingunitSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.HandlingunitSanitisedPayload Payload = 3; */
if (message.Payload)
HandlingunitSanitisedPayload.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.HandlingunitSanitisedRequest
*/
export const HandlingunitSanitisedRequest = new HandlingunitSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class HandlingunitSanitisedResponse$Type extends MessageType<HandlingunitSanitisedResponse> {
constructor() {
super("api.HandlingunitSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<HandlingunitSanitisedResponse>): HandlingunitSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<HandlingunitSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: HandlingunitSanitisedResponse): HandlingunitSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: HandlingunitSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.HandlingunitSanitisedResponse
*/
export const HandlingunitSanitisedResponse = new HandlingunitSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.HandlingunitInputAPI
*/
@@ -4008,5 +4271,6 @@ export const HandlingunitInputAPI = new ServiceType("api.HandlingunitInputAPI",
{ name: "ParentHUUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["HandlingUnit Inputs"], description: "Parent Hu us updated on an Handling Unit. This is called after HUAdded to propagate Parent HU." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: HandlingunitParentHUUpdatedRequest, O: HandlingunitParentHUUpdatedResponse },
{ name: "ClaimAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["HandlingUnit Inputs"], description: "A claim is added for the Handlingunit." }, "api.rscType": "Project", "api.roles": "Platform.Project-Claim", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: HandlingunitClaimAddedRequest, O: HandlingunitClaimAddedResponse },
{ name: "ReadyToBeCollected", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["HandlingUnit Inputs"], description: "HandlingUnit is available on Dock, Ready to be collected." }, "api.rscType": "Project", "api.roles": "Platform.Project-Claim", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: HandlingunitReadyToBeCollectedRequest, O: HandlingunitReadyToBeCollectedResponse },
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["HandlingUnit Inputs"], description: "An Handlingunit has been deleted. This is called from Reflex Platform Admin service to share the Organisation Handlingunits." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: HandlingunitDeletedRequest, O: HandlingunitDeletedResponse }
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["HandlingUnit Inputs"], description: "An Handlingunit has been deleted. This is called from Reflex Platform Admin service to share the Organisation Handlingunits." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: HandlingunitDeletedRequest, O: HandlingunitDeletedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["HandlingUnit Inputs"], description: "An Handlingunit has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: HandlingunitSanitisedRequest, O: HandlingunitSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

13
itemInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { ItemInputAPI } from "./itemInput";
import type { ItemSanitisedResponse } from "./itemInput";
import type { ItemSanitisedRequest } from "./itemInput";
import type { ItemAttachmentRemovedResponse } from "./itemInput";
import type { ItemAttachmentRemovedRequest } from "./itemInput";
import type { ItemAttachmentAddedResponse } from "./itemInput";
@@ -124,6 +126,10 @@ export interface IItemInputAPIClient {
* @generated from protobuf rpc: AttachmentRemoved
*/
attachmentRemoved(input: ItemAttachmentRemovedRequest, options?: RpcOptions): UnaryCall<ItemAttachmentRemovedRequest, ItemAttachmentRemovedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ItemSanitisedRequest, options?: RpcOptions): UnaryCall<ItemSanitisedRequest, ItemSanitisedResponse>;
}
//
// ClaimAdded : this message tells that a claim is added for the Item
@@ -255,4 +261,11 @@ export class ItemInputAPIClient implements IItemInputAPIClient, ServiceInfo {
const method = this.methods[7], opt = this._transport.mergeOptions(options);
return stackIntercept<ItemAttachmentRemovedRequest, ItemAttachmentRemovedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: ItemSanitisedRequest, options?: RpcOptions): UnaryCall<ItemSanitisedRequest, ItemSanitisedResponse> {
const method = this.methods[8], opt = this._transport.mergeOptions(options);
return stackIntercept<ItemSanitisedRequest, ItemSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
itemInput.ts
View File

@@ -558,6 +558,58 @@ export interface ItemAttachmentRemovedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.ItemSanitisedPayload
*/
export interface ItemSanitisedPayload {
}
/**
* @generated from protobuf message api.ItemSanitisedEvent
*/
export interface ItemSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ItemSanitisedPayload Payload = 3
*/
Payload?: ItemSanitisedPayload;
}
/**
* @generated from protobuf message api.ItemSanitisedRequest
*/
export interface ItemSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.ItemSanitisedPayload Payload = 3
*/
Payload?: ItemSanitisedPayload;
}
/**
* @generated from protobuf message api.ItemSanitisedResponse
*/
export interface ItemSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class ItemCreatedPayload$Type extends MessageType<ItemCreatedPayload> {
constructor() {
@@ -2340,6 +2392,217 @@ class ItemAttachmentRemovedResponse$Type extends MessageType<ItemAttachmentRemov
* @generated MessageType for protobuf message api.ItemAttachmentRemovedResponse
*/
export const ItemAttachmentRemovedResponse = new ItemAttachmentRemovedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemSanitisedPayload$Type extends MessageType<ItemSanitisedPayload> {
constructor() {
super("api.ItemSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ItemSanitisedPayload>): ItemSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemSanitisedPayload): ItemSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ItemSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ItemSanitisedPayload
*/
export const ItemSanitisedPayload = new ItemSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemSanitisedEvent$Type extends MessageType<ItemSanitisedEvent> {
constructor() {
super("api.ItemSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ItemSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<ItemSanitisedEvent>): ItemSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemSanitisedEvent): ItemSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ItemSanitisedPayload Payload */ 3:
message.Payload = ItemSanitisedPayload.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: ItemSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemSanitisedPayload Payload = 3; */
if (message.Payload)
ItemSanitisedPayload.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.ItemSanitisedEvent
*/
export const ItemSanitisedEvent = new ItemSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemSanitisedRequest$Type extends MessageType<ItemSanitisedRequest> {
constructor() {
super("api.ItemSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => ItemSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ItemSanitisedRequest>): ItemSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemSanitisedRequest): ItemSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.ItemSanitisedPayload Payload */ 3:
message.Payload = ItemSanitisedPayload.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: ItemSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.ItemSanitisedPayload Payload = 3; */
if (message.Payload)
ItemSanitisedPayload.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.ItemSanitisedRequest
*/
export const ItemSanitisedRequest = new ItemSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ItemSanitisedResponse$Type extends MessageType<ItemSanitisedResponse> {
constructor() {
super("api.ItemSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<ItemSanitisedResponse>): ItemSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<ItemSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ItemSanitisedResponse): ItemSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: ItemSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ItemSanitisedResponse
*/
export const ItemSanitisedResponse = new ItemSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.ItemInputAPI
*/
@@ -2351,5 +2614,6 @@ export const ItemInputAPI = new ServiceType("api.ItemInputAPI", [
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Item Inputs"], description: "An item has been deleted. This is typically called from ERP or WMS." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ItemDeletedRequest, O: ItemDeletedResponse },
{ name: "DescriptionUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Item Inputs"], description: "Some description have been updated on an item. This is typically called from ERP or WMS." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ItemDescriptionUpdatedRequest, O: ItemDescriptionUpdatedResponse },
{ name: "AttachmentAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Item Inputs"], description: "An attachment is added for the Item." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ItemAttachmentAddedRequest, O: ItemAttachmentAddedResponse },
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Item Inputs"], description: "An attachment is removed for the Item." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ItemAttachmentRemovedRequest, O: ItemAttachmentRemovedResponse }
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Item Inputs"], description: "An attachment is removed for the Item." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ItemAttachmentRemovedRequest, O: ItemAttachmentRemovedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Item Inputs"], description: "An Item has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: ItemSanitisedRequest, O: ItemSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

13
movementInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { MovementInputAPI } from "./movementInput";
import type { MovementSanitisedResponse } from "./movementInput";
import type { MovementSanitisedRequest } from "./movementInput";
import type { MovementDeletedResponse } from "./movementInput";
import type { MovementDeletedRequest } from "./movementInput";
import type { MovementAttachmentRemovedResponse } from "./movementInput";
@@ -56,6 +58,10 @@ export interface IMovementInputAPIClient {
* @generated from protobuf rpc: Deleted
*/
deleted(input: MovementDeletedRequest, options?: RpcOptions): UnaryCall<MovementDeletedRequest, MovementDeletedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: MovementSanitisedRequest, options?: RpcOptions): UnaryCall<MovementSanitisedRequest, MovementSanitisedResponse>;
}
/**
*
@@ -118,4 +124,11 @@ export class MovementInputAPIClient implements IMovementInputAPIClient, ServiceI
const method = this.methods[6], opt = this._transport.mergeOptions(options);
return stackIntercept<MovementDeletedRequest, MovementDeletedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: MovementSanitisedRequest, options?: RpcOptions): UnaryCall<MovementSanitisedRequest, MovementSanitisedResponse> {
const method = this.methods[7], opt = this._transport.mergeOptions(options);
return stackIntercept<MovementSanitisedRequest, MovementSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
movementInput.ts
View File

@@ -492,6 +492,58 @@ export interface MovementDeletedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.MovementSanitisedPayload
*/
export interface MovementSanitisedPayload {
}
/**
* @generated from protobuf message api.MovementSanitisedEvent
*/
export interface MovementSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.MovementSanitisedPayload Payload = 3
*/
Payload?: MovementSanitisedPayload;
}
/**
* @generated from protobuf message api.MovementSanitisedRequest
*/
export interface MovementSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.MovementSanitisedPayload Payload = 3
*/
Payload?: MovementSanitisedPayload;
}
/**
* @generated from protobuf message api.MovementSanitisedResponse
*/
export interface MovementSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class MovementCreatedPayload$Type extends MessageType<MovementCreatedPayload> {
constructor() {
@@ -2071,6 +2123,217 @@ class MovementDeletedResponse$Type extends MessageType<MovementDeletedResponse>
* @generated MessageType for protobuf message api.MovementDeletedResponse
*/
export const MovementDeletedResponse = new MovementDeletedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementSanitisedPayload$Type extends MessageType<MovementSanitisedPayload> {
constructor() {
super("api.MovementSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<MovementSanitisedPayload>): MovementSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementSanitisedPayload): MovementSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: MovementSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.MovementSanitisedPayload
*/
export const MovementSanitisedPayload = new MovementSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementSanitisedEvent$Type extends MessageType<MovementSanitisedEvent> {
constructor() {
super("api.MovementSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => MovementSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<MovementSanitisedEvent>): MovementSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementSanitisedEvent): MovementSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.MovementSanitisedPayload Payload */ 3:
message.Payload = MovementSanitisedPayload.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: MovementSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementSanitisedPayload Payload = 3; */
if (message.Payload)
MovementSanitisedPayload.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.MovementSanitisedEvent
*/
export const MovementSanitisedEvent = new MovementSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementSanitisedRequest$Type extends MessageType<MovementSanitisedRequest> {
constructor() {
super("api.MovementSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => MovementSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<MovementSanitisedRequest>): MovementSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementSanitisedRequest): MovementSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.MovementSanitisedPayload Payload */ 3:
message.Payload = MovementSanitisedPayload.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: MovementSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.MovementSanitisedPayload Payload = 3; */
if (message.Payload)
MovementSanitisedPayload.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.MovementSanitisedRequest
*/
export const MovementSanitisedRequest = new MovementSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class MovementSanitisedResponse$Type extends MessageType<MovementSanitisedResponse> {
constructor() {
super("api.MovementSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<MovementSanitisedResponse>): MovementSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<MovementSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: MovementSanitisedResponse): MovementSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: MovementSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.MovementSanitisedResponse
*/
export const MovementSanitisedResponse = new MovementSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.MovementInputAPI
*/
@@ -2081,5 +2344,6 @@ export const MovementInputAPI = new ServiceType("api.MovementInputAPI", [
{ name: "ClaimAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Movement Inputs"], description: "A claim is added for the Stock movement." }, "api.rscType": "Project", "api.roles": "Platform.Project-Claim", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: MovementClaimAddedRequest, O: MovementClaimAddedResponse },
{ name: "AttachmentAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Movement Inputs"], description: "An attachment is added for the Movement." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: MovementAttachmentAddedRequest, O: MovementAttachmentAddedResponse },
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Movement Inputs"], description: "An attachment is removed for the Movement." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: MovementAttachmentRemovedRequest, O: MovementAttachmentRemovedResponse },
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Movement Inputs"], description: "An Movement has been deleted. This is called from Reflex Platform Admin service to share the Organisation Movements." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: MovementDeletedRequest, O: MovementDeletedResponse }
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Movement Inputs"], description: "An Movement has been deleted. This is called from Reflex Platform Admin service to share the Organisation Movements." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: MovementDeletedRequest, O: MovementDeletedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Movement Inputs"], description: "A Movement has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: MovementSanitisedRequest, O: MovementSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

13
notifInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { NotifInputAPI } from "./notifInput";
import type { NotifSanitisedResponse } from "./notifInput";
import type { NotifSanitisedRequest } from "./notifInput";
import { stackIntercept } from "@protobuf-ts/runtime-rpc";
import type { NotifCreatedResponse } from "./notifInput";
import type { NotifCreatedRequest } from "./notifInput";
@@ -20,6 +22,10 @@ export interface INotifInputAPIClient {
* @generated from protobuf rpc: Created
*/
created(input: NotifCreatedRequest, options?: RpcOptions): UnaryCall<NotifCreatedRequest, NotifCreatedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: NotifSanitisedRequest, options?: RpcOptions): UnaryCall<NotifSanitisedRequest, NotifSanitisedResponse>;
}
/**
*
@@ -40,4 +46,11 @@ export class NotifInputAPIClient implements INotifInputAPIClient, ServiceInfo {
const method = this.methods[0], opt = this._transport.mergeOptions(options);
return stackIntercept<NotifCreatedRequest, NotifCreatedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: NotifSanitisedRequest, options?: RpcOptions): UnaryCall<NotifSanitisedRequest, NotifSanitisedResponse> {
const method = this.methods[1], opt = this._transport.mergeOptions(options);
return stackIntercept<NotifSanitisedRequest, NotifSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
notifInput.ts
View File

@@ -123,6 +123,58 @@ export interface NotifCreatedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.NotifSanitisedPayload
*/
export interface NotifSanitisedPayload {
}
/**
* @generated from protobuf message api.NotifSanitisedEvent
*/
export interface NotifSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.NotifSanitisedPayload Payload = 3
*/
Payload?: NotifSanitisedPayload;
}
/**
* @generated from protobuf message api.NotifSanitisedRequest
*/
export interface NotifSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.NotifSanitisedPayload Payload = 3
*/
Payload?: NotifSanitisedPayload;
}
/**
* @generated from protobuf message api.NotifSanitisedResponse
*/
export interface NotifSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class NotifCreatedPayload$Type extends MessageType<NotifCreatedPayload> {
constructor() {
@@ -399,9 +451,221 @@ class NotifCreatedResponse$Type extends MessageType<NotifCreatedResponse> {
* @generated MessageType for protobuf message api.NotifCreatedResponse
*/
export const NotifCreatedResponse = new NotifCreatedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class NotifSanitisedPayload$Type extends MessageType<NotifSanitisedPayload> {
constructor() {
super("api.NotifSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<NotifSanitisedPayload>): NotifSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<NotifSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NotifSanitisedPayload): NotifSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: NotifSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.NotifSanitisedPayload
*/
export const NotifSanitisedPayload = new NotifSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class NotifSanitisedEvent$Type extends MessageType<NotifSanitisedEvent> {
constructor() {
super("api.NotifSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => NotifSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<NotifSanitisedEvent>): NotifSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<NotifSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NotifSanitisedEvent): NotifSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.NotifSanitisedPayload Payload */ 3:
message.Payload = NotifSanitisedPayload.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: NotifSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.NotifSanitisedPayload Payload = 3; */
if (message.Payload)
NotifSanitisedPayload.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.NotifSanitisedEvent
*/
export const NotifSanitisedEvent = new NotifSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class NotifSanitisedRequest$Type extends MessageType<NotifSanitisedRequest> {
constructor() {
super("api.NotifSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => NotifSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<NotifSanitisedRequest>): NotifSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<NotifSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NotifSanitisedRequest): NotifSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.NotifSanitisedPayload Payload */ 3:
message.Payload = NotifSanitisedPayload.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: NotifSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.NotifSanitisedPayload Payload = 3; */
if (message.Payload)
NotifSanitisedPayload.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.NotifSanitisedRequest
*/
export const NotifSanitisedRequest = new NotifSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class NotifSanitisedResponse$Type extends MessageType<NotifSanitisedResponse> {
constructor() {
super("api.NotifSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<NotifSanitisedResponse>): NotifSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<NotifSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: NotifSanitisedResponse): NotifSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: NotifSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.NotifSanitisedResponse
*/
export const NotifSanitisedResponse = new NotifSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.NotifInputAPI
*/
export const NotifInputAPI = new ServiceType("api.NotifInputAPI", [
{ name: "Created", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Notification Inputs"], description: "A notification has been created." }, "api.rscType": "Project", "api.roles": "Platform.Project-Notication", "api.platformReserved": true, "google.api.method_visibility": { restriction: "SDK" } }, I: NotifCreatedRequest, O: NotifCreatedResponse }
{ name: "Created", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Notification Inputs"], description: "A notification has been created." }, "api.rscType": "Project", "api.roles": "Platform.Project-Notication", "api.platformReserved": true, "google.api.method_visibility": { restriction: "SDK" } }, I: NotifCreatedRequest, O: NotifCreatedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Notification Inputs"], description: "A Notif has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: NotifSanitisedRequest, O: NotifSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "collab-api-server" });

13
orderInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { OrderInputAPI } from "./orderInput";
import type { OrderSanitisedResponse } from "./orderInput";
import type { OrderSanitisedRequest } from "./orderInput";
import type { OrderLinesDetectedResponse } from "./orderInput";
import type { OrderLinesDetectedRequest } from "./orderInput";
import type { OrderLinesAddedResponse } from "./orderInput";
@@ -122,6 +124,10 @@ export interface IOrderInputAPIClient {
* @generated from protobuf rpc: LinesDetected
*/
linesDetected(input: OrderLinesDetectedRequest, options?: RpcOptions): UnaryCall<OrderLinesDetectedRequest, OrderLinesDetectedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: OrderSanitisedRequest, options?: RpcOptions): UnaryCall<OrderSanitisedRequest, OrderSanitisedResponse>;
}
/**
*
@@ -261,4 +267,11 @@ export class OrderInputAPIClient implements IOrderInputAPIClient, ServiceInfo {
const method = this.methods[17], opt = this._transport.mergeOptions(options);
return stackIntercept<OrderLinesDetectedRequest, OrderLinesDetectedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: OrderSanitisedRequest, options?: RpcOptions): UnaryCall<OrderSanitisedRequest, OrderSanitisedResponse> {
const method = this.methods[18], opt = this._transport.mergeOptions(options);
return stackIntercept<OrderSanitisedRequest, OrderSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
orderInput.ts
View File

@@ -371,6 +371,58 @@ export interface OrderAnonymisedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.OrderSanitisedPayload
*/
export interface OrderSanitisedPayload {
}
/**
* @generated from protobuf message api.OrderSanitisedEvent
*/
export interface OrderSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.OrderSanitisedPayload Payload = 3
*/
Payload?: OrderSanitisedPayload;
}
/**
* @generated from protobuf message api.OrderSanitisedRequest
*/
export interface OrderSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.OrderSanitisedPayload Payload = 3
*/
Payload?: OrderSanitisedPayload;
}
/**
* @generated from protobuf message api.OrderSanitisedResponse
*/
export interface OrderSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// ShipperAssigned
/**
@@ -2278,6 +2330,217 @@ class OrderAnonymisedResponse$Type extends MessageType<OrderAnonymisedResponse>
*/
export const OrderAnonymisedResponse = new OrderAnonymisedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OrderSanitisedPayload$Type extends MessageType<OrderSanitisedPayload> {
constructor() {
super("api.OrderSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<OrderSanitisedPayload>): OrderSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<OrderSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderSanitisedPayload): OrderSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: OrderSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.OrderSanitisedPayload
*/
export const OrderSanitisedPayload = new OrderSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OrderSanitisedEvent$Type extends MessageType<OrderSanitisedEvent> {
constructor() {
super("api.OrderSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<OrderSanitisedEvent>): OrderSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<OrderSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderSanitisedEvent): OrderSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.OrderSanitisedPayload Payload */ 3:
message.Payload = OrderSanitisedPayload.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: OrderSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.OrderSanitisedPayload Payload = 3; */
if (message.Payload)
OrderSanitisedPayload.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.OrderSanitisedEvent
*/
export const OrderSanitisedEvent = new OrderSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OrderSanitisedRequest$Type extends MessageType<OrderSanitisedRequest> {
constructor() {
super("api.OrderSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => OrderSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<OrderSanitisedRequest>): OrderSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<OrderSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderSanitisedRequest): OrderSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.OrderSanitisedPayload Payload */ 3:
message.Payload = OrderSanitisedPayload.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: OrderSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.OrderSanitisedPayload Payload = 3; */
if (message.Payload)
OrderSanitisedPayload.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.OrderSanitisedRequest
*/
export const OrderSanitisedRequest = new OrderSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OrderSanitisedResponse$Type extends MessageType<OrderSanitisedResponse> {
constructor() {
super("api.OrderSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<OrderSanitisedResponse>): OrderSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<OrderSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OrderSanitisedResponse): OrderSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: OrderSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.OrderSanitisedResponse
*/
export const OrderSanitisedResponse = new OrderSanitisedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class OrderShipperAssignedPayload$Type extends MessageType<OrderShipperAssignedPayload> {
constructor() {
super("api.OrderShipperAssignedPayload", [
@@ -5364,5 +5627,6 @@ export const OrderInputAPI = new ServiceType("api.OrderInputAPI", [
{ name: "ClaimAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "A claim is added for the Order." }, "api.rscType": "Project", "api.roles": "Platform.Project-Claim", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderClaimAddedRequest, O: OrderClaimAddedResponse },
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An Order has been deleted. This is called from Reflex Platform Admin service to share the Organisation Orders." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderDeletedRequest, O: OrderDeletedResponse },
{ name: "LinesAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "Some lines are added for the Order." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "PUBLIC" } }, I: OrderLinesAddedRequest, O: OrderLinesAddedResponse },
{ name: "LinesDetected", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "Adding lines in the Executionflow has been reported to an Order. This is called internally." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderLinesDetectedRequest, O: OrderLinesDetectedResponse }
{ name: "LinesDetected", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "Adding lines in the Executionflow has been reported to an Order. This is called internally." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderLinesDetectedRequest, O: OrderLinesDetectedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Order Inputs"], description: "An Order has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: OrderSanitisedRequest, O: OrderSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

2
package.json
View File

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

13
partnerInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { PartnerInputAPI } from "./partnerInput";
import type { PartnerSanitisedResponse } from "./partnerInput";
import type { PartnerSanitisedRequest } from "./partnerInput";
import type { PartnerAttachmentRemovedResponse } from "./partnerInput";
import type { PartnerAttachmentRemovedRequest } from "./partnerInput";
import type { PartnerAttachmentAddedResponse } from "./partnerInput";
@@ -100,6 +102,10 @@ export interface IPartnerInputAPIClient {
* @generated from protobuf rpc: AttachmentRemoved
*/
attachmentRemoved(input: PartnerAttachmentRemovedRequest, options?: RpcOptions): UnaryCall<PartnerAttachmentRemovedRequest, PartnerAttachmentRemovedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: PartnerSanitisedRequest, options?: RpcOptions): UnaryCall<PartnerSanitisedRequest, PartnerSanitisedResponse>;
}
//
// ClaimAdded : this message tells that a claim is added for the Partner
@@ -203,4 +209,11 @@ export class PartnerInputAPIClient implements IPartnerInputAPIClient, ServiceInf
const method = this.methods[3], opt = this._transport.mergeOptions(options);
return stackIntercept<PartnerAttachmentRemovedRequest, PartnerAttachmentRemovedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: PartnerSanitisedRequest, options?: RpcOptions): UnaryCall<PartnerSanitisedRequest, PartnerSanitisedResponse> {
const method = this.methods[4], opt = this._transport.mergeOptions(options);
return stackIntercept<PartnerSanitisedRequest, PartnerSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
partnerInput.ts
View File

@@ -281,6 +281,58 @@ export interface PartnerAttachmentRemovedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.PartnerSanitisedPayload
*/
export interface PartnerSanitisedPayload {
}
/**
* @generated from protobuf message api.PartnerSanitisedEvent
*/
export interface PartnerSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.PartnerSanitisedPayload Payload = 3
*/
Payload?: PartnerSanitisedPayload;
}
/**
* @generated from protobuf message api.PartnerSanitisedRequest
*/
export interface PartnerSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.PartnerSanitisedPayload Payload = 3
*/
Payload?: PartnerSanitisedPayload;
}
/**
* @generated from protobuf message api.PartnerSanitisedResponse
*/
export interface PartnerSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class PartnerCreatedPayload$Type extends MessageType<PartnerCreatedPayload> {
constructor() {
@@ -1183,6 +1235,217 @@ class PartnerAttachmentRemovedResponse$Type extends MessageType<PartnerAttachmen
* @generated MessageType for protobuf message api.PartnerAttachmentRemovedResponse
*/
export const PartnerAttachmentRemovedResponse = new PartnerAttachmentRemovedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerSanitisedPayload$Type extends MessageType<PartnerSanitisedPayload> {
constructor() {
super("api.PartnerSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<PartnerSanitisedPayload>): PartnerSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerSanitisedPayload): PartnerSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: PartnerSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.PartnerSanitisedPayload
*/
export const PartnerSanitisedPayload = new PartnerSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerSanitisedEvent$Type extends MessageType<PartnerSanitisedEvent> {
constructor() {
super("api.PartnerSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => PartnerSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<PartnerSanitisedEvent>): PartnerSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerSanitisedEvent): PartnerSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.PartnerSanitisedPayload Payload */ 3:
message.Payload = PartnerSanitisedPayload.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: PartnerSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.PartnerSanitisedPayload Payload = 3; */
if (message.Payload)
PartnerSanitisedPayload.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.PartnerSanitisedEvent
*/
export const PartnerSanitisedEvent = new PartnerSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerSanitisedRequest$Type extends MessageType<PartnerSanitisedRequest> {
constructor() {
super("api.PartnerSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => PartnerSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<PartnerSanitisedRequest>): PartnerSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerSanitisedRequest): PartnerSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.PartnerSanitisedPayload Payload */ 3:
message.Payload = PartnerSanitisedPayload.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: PartnerSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.PartnerSanitisedPayload Payload = 3; */
if (message.Payload)
PartnerSanitisedPayload.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.PartnerSanitisedRequest
*/
export const PartnerSanitisedRequest = new PartnerSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class PartnerSanitisedResponse$Type extends MessageType<PartnerSanitisedResponse> {
constructor() {
super("api.PartnerSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<PartnerSanitisedResponse>): PartnerSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<PartnerSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PartnerSanitisedResponse): PartnerSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: PartnerSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.PartnerSanitisedResponse
*/
export const PartnerSanitisedResponse = new PartnerSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.PartnerInputAPI
*/
@@ -1190,5 +1453,6 @@ export const PartnerInputAPI = new ServiceType("api.PartnerInputAPI", [
{ name: "Created", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Partner Inputs"], description: "An Partner has been created. This is called from Reflex Platform Admin service to share the Organisation partners. For each created partner, a user group should be created by calling api.UserGroupsService/Put." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: PartnerCreatedRequest, O: PartnerCreatedResponse },
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Partner Inputs"], description: "An Partner has been deleted. This is called from Reflex Platform Admin service to share the Organisation partners." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: PartnerDeletedRequest, O: PartnerDeletedResponse },
{ name: "AttachmentAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Partner Inputs"], description: "An attachment is added for the Partner." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: PartnerAttachmentAddedRequest, O: PartnerAttachmentAddedResponse },
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Partner Inputs"], description: "An attachment is removed for the Partner." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: PartnerAttachmentRemovedRequest, O: PartnerAttachmentRemovedResponse }
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Partner Inputs"], description: "An attachment is removed for the Partner." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: PartnerAttachmentRemovedRequest, O: PartnerAttachmentRemovedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Partner Inputs"], description: "A Partner has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: PartnerSanitisedRequest, O: PartnerSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

13
stockInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { StockInputAPI } from "./stockInput";
import type { StockSanitisedResponse } from "./stockInput";
import type { StockSanitisedRequest } from "./stockInput";
import type { StockDeletedResponse } from "./stockInput";
import type { StockDeletedRequest } from "./stockInput";
import type { StockSnapshottedResponse } from "./stockInput";
@@ -33,6 +35,10 @@ export interface IStockInputAPIClient {
* @generated from protobuf rpc: Deleted
*/
deleted(input: StockDeletedRequest, options?: RpcOptions): UnaryCall<StockDeletedRequest, StockDeletedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: StockSanitisedRequest, options?: RpcOptions): UnaryCall<StockSanitisedRequest, StockSanitisedResponse>;
}
/**
*
@@ -68,4 +74,11 @@ export class StockInputAPIClient implements IStockInputAPIClient, ServiceInfo {
const method = this.methods[2], opt = this._transport.mergeOptions(options);
return stackIntercept<StockDeletedRequest, StockDeletedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: StockSanitisedRequest, options?: RpcOptions): UnaryCall<StockSanitisedRequest, StockSanitisedResponse> {
const method = this.methods[3], opt = this._transport.mergeOptions(options);
return stackIntercept<StockSanitisedRequest, StockSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
stockInput.ts
View File

@@ -282,6 +282,58 @@ export interface StockDeletedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.StockSanitisedPayload
*/
export interface StockSanitisedPayload {
}
/**
* @generated from protobuf message api.StockSanitisedEvent
*/
export interface StockSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.StockSanitisedPayload Payload = 3
*/
Payload?: StockSanitisedPayload;
}
/**
* @generated from protobuf message api.StockSanitisedRequest
*/
export interface StockSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.StockSanitisedPayload Payload = 3
*/
Payload?: StockSanitisedPayload;
}
/**
* @generated from protobuf message api.StockSanitisedResponse
*/
export interface StockSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class StockMovedPayload$Type extends MessageType<StockMovedPayload> {
constructor() {
@@ -998,11 +1050,223 @@ class StockDeletedResponse$Type extends MessageType<StockDeletedResponse> {
* @generated MessageType for protobuf message api.StockDeletedResponse
*/
export const StockDeletedResponse = new StockDeletedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockSanitisedPayload$Type extends MessageType<StockSanitisedPayload> {
constructor() {
super("api.StockSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<StockSanitisedPayload>): StockSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<StockSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StockSanitisedPayload): StockSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: StockSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.StockSanitisedPayload
*/
export const StockSanitisedPayload = new StockSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockSanitisedEvent$Type extends MessageType<StockSanitisedEvent> {
constructor() {
super("api.StockSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => StockSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<StockSanitisedEvent>): StockSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<StockSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StockSanitisedEvent): StockSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.StockSanitisedPayload Payload */ 3:
message.Payload = StockSanitisedPayload.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: StockSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.StockSanitisedPayload Payload = 3; */
if (message.Payload)
StockSanitisedPayload.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.StockSanitisedEvent
*/
export const StockSanitisedEvent = new StockSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockSanitisedRequest$Type extends MessageType<StockSanitisedRequest> {
constructor() {
super("api.StockSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => StockSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<StockSanitisedRequest>): StockSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<StockSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StockSanitisedRequest): StockSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.StockSanitisedPayload Payload */ 3:
message.Payload = StockSanitisedPayload.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: StockSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.StockSanitisedPayload Payload = 3; */
if (message.Payload)
StockSanitisedPayload.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.StockSanitisedRequest
*/
export const StockSanitisedRequest = new StockSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class StockSanitisedResponse$Type extends MessageType<StockSanitisedResponse> {
constructor() {
super("api.StockSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<StockSanitisedResponse>): StockSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<StockSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: StockSanitisedResponse): StockSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: StockSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.StockSanitisedResponse
*/
export const StockSanitisedResponse = new StockSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.StockInputAPI
*/
export const StockInputAPI = new ServiceType("api.StockInputAPI", [
{ name: "Moved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Inputs"], description: "A stock has been moved. Called internally from Movement entity." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "INTERNAL" } }, I: StockMovedRequest, O: StockMovedResponse },
{ name: "Snapshotted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Inputs"], description: "A stock image (snapshot) has been sent. This is typically called from a WMS." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: StockSnapshottedRequest, O: StockSnapshottedResponse },
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Inputs"], description: "Deprecated from 1.8. A stock entry has been deleted. This is typically called from a WMS." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: StockDeletedRequest, O: StockDeletedResponse }
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Inputs"], description: "Deprecated from 1.8. A stock entry has been deleted. This is typically called from a WMS." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: StockDeletedRequest, O: StockDeletedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Stock Inputs"], description: "A Stock has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: StockSanitisedRequest, O: StockSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });

13
trackingInput.client.ts
View File

@@ -4,6 +4,8 @@
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { TrackingInputAPI } from "./trackingInput";
import type { TrackingSanitisedResponse } from "./trackingInput";
import type { TrackingSanitisedRequest } from "./trackingInput";
import type { TrackingURLUpdatedResponse } from "./trackingInput";
import type { TrackingURLUpdatedRequest } from "./trackingInput";
import type { TrackingDeletedResponse } from "./trackingInput";
@@ -69,6 +71,10 @@ export interface ITrackingInputAPIClient {
* @generated from protobuf rpc: URLUpdated
*/
uRLUpdated(input: TrackingURLUpdatedRequest, options?: RpcOptions): UnaryCall<TrackingURLUpdatedRequest, TrackingURLUpdatedResponse>;
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: TrackingSanitisedRequest, options?: RpcOptions): UnaryCall<TrackingSanitisedRequest, TrackingSanitisedResponse>;
}
/**
*
@@ -146,4 +152,11 @@ export class TrackingInputAPIClient implements ITrackingInputAPIClient, ServiceI
const method = this.methods[8], opt = this._transport.mergeOptions(options);
return stackIntercept<TrackingURLUpdatedRequest, TrackingURLUpdatedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Sanitised
*/
sanitised(input: TrackingSanitisedRequest, options?: RpcOptions): UnaryCall<TrackingSanitisedRequest, TrackingSanitisedResponse> {
const method = this.methods[9], opt = this._transport.mergeOptions(options);
return stackIntercept<TrackingSanitisedRequest, TrackingSanitisedResponse>("unary", this._transport, method, opt, input);
}
}

266
trackingInput.ts
View File

@@ -644,6 +644,58 @@ export interface TrackingDeletedResponse {
*/
ID?: EntityID;
}
/**
* @generated from protobuf message api.TrackingSanitisedPayload
*/
export interface TrackingSanitisedPayload {
}
/**
* @generated from protobuf message api.TrackingSanitisedEvent
*/
export interface TrackingSanitisedEvent {
/**
* @generated from protobuf field: api.EventHeader Header = 1
*/
Header?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.TrackingSanitisedPayload Payload = 3
*/
Payload?: TrackingSanitisedPayload;
}
/**
* @generated from protobuf message api.TrackingSanitisedRequest
*/
export interface TrackingSanitisedRequest {
/**
* @generated from protobuf field: api.RequestProjectHeader Header = 1
*/
Header?: RequestProjectHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
/**
* @generated from protobuf field: api.TrackingSanitisedPayload Payload = 3
*/
Payload?: TrackingSanitisedPayload;
}
/**
* @generated from protobuf message api.TrackingSanitisedResponse
*/
export interface TrackingSanitisedResponse {
/**
* @generated from protobuf field: api.ResponseHeader Header = 1
*/
Header?: ResponseHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2
*/
ID?: EntityID;
}
// @generated message type with reflection information, may provide speed optimized methods
class TrackingNotifiedPayload$Type extends MessageType<TrackingNotifiedPayload> {
constructor() {
@@ -2708,6 +2760,217 @@ class TrackingDeletedResponse$Type extends MessageType<TrackingDeletedResponse>
* @generated MessageType for protobuf message api.TrackingDeletedResponse
*/
export const TrackingDeletedResponse = new TrackingDeletedResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingSanitisedPayload$Type extends MessageType<TrackingSanitisedPayload> {
constructor() {
super("api.TrackingSanitisedPayload", [], { "api.messageType": "Event", "api.payload": true, "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<TrackingSanitisedPayload>): TrackingSanitisedPayload {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingSanitisedPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingSanitisedPayload): TrackingSanitisedPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: TrackingSanitisedPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.TrackingSanitisedPayload
*/
export const TrackingSanitisedPayload = new TrackingSanitisedPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingSanitisedEvent$Type extends MessageType<TrackingSanitisedEvent> {
constructor() {
super("api.TrackingSanitisedEvent", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => EventHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => TrackingSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "api.messageType": "Event", "api.inputEvent": "Sanitised", "api.postAggMethods": "sanitise" });
}
create(value?: PartialMessage<TrackingSanitisedEvent>): TrackingSanitisedEvent {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingSanitisedEvent>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingSanitisedEvent): TrackingSanitisedEvent {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader Header */ 1:
message.Header = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.TrackingSanitisedPayload Payload */ 3:
message.Payload = TrackingSanitisedPayload.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: TrackingSanitisedEvent, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader Header = 1; */
if (message.Header)
EventHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingSanitisedPayload Payload = 3; */
if (message.Payload)
TrackingSanitisedPayload.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.TrackingSanitisedEvent
*/
export const TrackingSanitisedEvent = new TrackingSanitisedEvent$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingSanitisedRequest$Type extends MessageType<TrackingSanitisedRequest> {
constructor() {
super("api.TrackingSanitisedRequest", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => RequestProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID, options: { "validate.rules": { message: { required: true } } } },
{ no: 3, name: "Payload", kind: "message", localName: "Payload", jsonName: "Payload", T: () => TrackingSanitisedPayload, options: { "validate.rules": { message: { required: true } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "ID", "Payload"] } }, "api.messageType": "Request", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<TrackingSanitisedRequest>): TrackingSanitisedRequest {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingSanitisedRequest>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingSanitisedRequest): TrackingSanitisedRequest {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.RequestProjectHeader Header */ 1:
message.Header = RequestProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
case /* api.TrackingSanitisedPayload Payload */ 3:
message.Payload = TrackingSanitisedPayload.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: TrackingSanitisedRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.RequestProjectHeader Header = 1; */
if (message.Header)
RequestProjectHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.TrackingSanitisedPayload Payload = 3; */
if (message.Payload)
TrackingSanitisedPayload.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.TrackingSanitisedRequest
*/
export const TrackingSanitisedRequest = new TrackingSanitisedRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class TrackingSanitisedResponse$Type extends MessageType<TrackingSanitisedResponse> {
constructor() {
super("api.TrackingSanitisedResponse", [
{ no: 1, name: "Header", kind: "message", localName: "Header", jsonName: "Header", T: () => ResponseHeader },
{ no: 2, name: "ID", kind: "message", localName: "ID", jsonName: "ID", T: () => EntityID }
], { "api.messageType": "Response", "api.inputEvent": "Sanitised" });
}
create(value?: PartialMessage<TrackingSanitisedResponse>): TrackingSanitisedResponse {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<TrackingSanitisedResponse>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TrackingSanitisedResponse): TrackingSanitisedResponse {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResponseHeader Header */ 1:
message.Header = ResponseHeader.internalBinaryRead(reader, reader.uint32(), options, message.Header);
break;
case /* api.EntityID ID */ 2:
message.ID = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.ID);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
let d = reader.skip(wireType);
if (u !== false)
(u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
}
}
return message;
}
internalBinaryWrite(message: TrackingSanitisedResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResponseHeader Header = 1; */
if (message.Header)
ResponseHeader.internalBinaryWrite(message.Header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2; */
if (message.ID)
EntityID.internalBinaryWrite(message.ID, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.TrackingSanitisedResponse
*/
export const TrackingSanitisedResponse = new TrackingSanitisedResponse$Type();
/**
* @generated ServiceType for protobuf service api.TrackingInputAPI
*/
@@ -2720,5 +2983,6 @@ export const TrackingInputAPI = new ServiceType("api.TrackingInputAPI", [
{ name: "AttachmentAdded", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Tracking Inputs"], description: "An attachment is added for the Tracking." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: TrackingAttachmentAddedRequest, O: TrackingAttachmentAddedResponse },
{ name: "AttachmentRemoved", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Tracking Inputs"], description: "An attachment is removed for the Tracking." }, "api.rscType": "Project", "api.roles": "Platform.Project-Attachment", "api.platformReserved": true, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: TrackingAttachmentRemovedRequest, O: TrackingAttachmentRemovedResponse },
{ name: "Deleted", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Tracking Inputs"], description: "An Tracking has been deleted. This is called from Reflex Platform Admin service to share the Organisation Trackings." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: TrackingDeletedRequest, O: TrackingDeletedResponse },
{ name: "URLUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Tracking Inputs"], description: "The tracking URL has been updated." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: TrackingURLUpdatedRequest, O: TrackingURLUpdatedResponse }
{ name: "URLUpdated", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Tracking Inputs"], description: "The tracking URL has been updated." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: TrackingURLUpdatedRequest, O: TrackingURLUpdatedResponse },
{ name: "Sanitised", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Tracking Inputs"], description: "A Tracking has been sanitised." }, "api.rscType": "Project", "api.roles": "Platform.Project-Input", "api.platformReserved": false, "google.api.method_visibility": { restriction: "INTERNAL" } }, I: TrackingSanitisedRequest, O: TrackingSanitisedResponse }
], { "api.serviceType": "Api", "api.k8sService": "api-server" });