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-04-28 11:35:40 +00:00
parent 27d08cc0b6
commit 595d5e3e36
16 changed files with 11440 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
actor.ts
View File

@@ -11,6 +11,8 @@ import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { PartnerPayload } from "./partner";
import { ActorAuthorisation } from "./slotbooking";
import { SiteAlias } from "./repositoryShared";
import { ClaimSummary } from "./shared";
import { AttachmentSummary } from "./shared";
import { CarrierService } from "./repositoryShared";
@@ -169,6 +171,18 @@ export interface ActorPayload {
* @generated from protobuf field: repeated string ConnectionIdentifierPrefixes = 28 [json_name = "ConnectionIdentifierPrefixes"];
*/
connectionIdentifierPrefixes: string[];
/**
* @generated from protobuf field: bool IsSlotBookingEnabled = 29 [json_name = "IsSlotBookingEnabled"];
*/
isSlotBookingEnabled: boolean;
/**
* @generated from protobuf field: api.SiteAlias SiteAlias = 30 [json_name = "SiteAlias"];
*/
siteAlias?: SiteAlias;
/**
* @generated from protobuf field: api.ActorAuthorisation AppointmentConstraints = 31 [json_name = "AppointmentConstraints"];
*/
appointmentConstraints?: ActorAuthorisation;
}
/**
* Actor Enrichment : Obsolete
@@ -325,7 +339,10 @@ class ActorPayload$Type extends MessageType<ActorPayload> {
{ no: 24, name: "Claims", kind: "message", jsonName: "Claims", repeat: 1 /*RepeatType.PACKED*/, T: () => ClaimSummary, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of claims per type" }, "api.aggKey": "ClaimTypeID", "api.aggSkip": "ClaimAdded", "api.enrichmentClear": "Order,Executionflow,Stock,Movement,Tracking" } },
{ no: 25, name: "ClaimNumber", kind: "scalar", jsonName: "ClaimNumber", T: 5 /*ScalarType.INT32*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Total number of claims" }, "api.enrichmentClear": "Order,Stock,Movement,Tracking" } },
{ no: 26, name: "PhotoURI", kind: "scalar", jsonName: "PhotoURI", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { example: "\"https://reflex-visibility-forever.jpg\"" }, "api.kpiItems": { Items: [{ Context: "Actor", Group: "actor", Queryable: true }, { Context: "Executionflow", Group: "executionflow", Queryable: true }, { Context: "Stock", Group: "stock", Queryable: true }, { Context: "Stock", Group: "stock_extended", Queryable: true, CustomType: "SimpleAggregateFunction(anyLast,String)" }] }, "api.viewType": { Types: [{ Context: "*", Type: "image" }] } } },
{ no: 28, name: "ConnectionIdentifierPrefixes", kind: "scalar", jsonName: "ConnectionIdentifierPrefixes", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/, options: { "api.enrichmentClear": "Stock,Movement,Tracking" } }
{ no: 28, name: "ConnectionIdentifierPrefixes", kind: "scalar", jsonName: "ConnectionIdentifierPrefixes", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/, options: { "api.enrichmentClear": "Stock,Movement,Tracking" } },
{ no: 29, name: "IsSlotBookingEnabled", kind: "scalar", jsonName: "IsSlotBookingEnabled", T: 8 /*ScalarType.BOOL*/, options: { "api.enrichmentClear": "Stock,Movement,Tracking" } },
{ no: 30, name: "SiteAlias", kind: "message", jsonName: "SiteAlias", T: () => SiteAlias, options: { "api.enrichmentClear": "Stock,Movement,Tracking" } },
{ no: 31, name: "AppointmentConstraints", kind: "message", jsonName: "AppointmentConstraints", T: () => ActorAuthorisation }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Name"] } } });
}
create(value?: PartialMessage<ActorPayload>): ActorPayload {
@@ -351,6 +368,7 @@ class ActorPayload$Type extends MessageType<ActorPayload> {
message.claimNumber = 0;
message.photoURI = "";
message.connectionIdentifierPrefixes = [];
message.isSlotBookingEnabled = false;
if (value !== undefined)
reflectionMergePartial<ActorPayload>(this, message, value);
return message;
@@ -432,6 +450,15 @@ class ActorPayload$Type extends MessageType<ActorPayload> {
case /* repeated string ConnectionIdentifierPrefixes = 28 [json_name = "ConnectionIdentifierPrefixes"];*/ 28:
message.connectionIdentifierPrefixes.push(reader.string());
break;
case /* bool IsSlotBookingEnabled = 29 [json_name = "IsSlotBookingEnabled"];*/ 29:
message.isSlotBookingEnabled = reader.bool();
break;
case /* api.SiteAlias SiteAlias = 30 [json_name = "SiteAlias"];*/ 30:
message.siteAlias = SiteAlias.internalBinaryRead(reader, reader.uint32(), options, message.siteAlias);
break;
case /* api.ActorAuthorisation AppointmentConstraints = 31 [json_name = "AppointmentConstraints"];*/ 31:
message.appointmentConstraints = ActorAuthorisation.internalBinaryRead(reader, reader.uint32(), options, message.appointmentConstraints);
break;
default:
let u = options.readUnknownField;
if (u === "throw")
@@ -516,6 +543,15 @@ class ActorPayload$Type extends MessageType<ActorPayload> {
/* repeated string ConnectionIdentifierPrefixes = 28 [json_name = "ConnectionIdentifierPrefixes"]; */
for (let i = 0; i < message.connectionIdentifierPrefixes.length; i++)
writer.tag(28, WireType.LengthDelimited).string(message.connectionIdentifierPrefixes[i]);
/* bool IsSlotBookingEnabled = 29 [json_name = "IsSlotBookingEnabled"]; */
if (message.isSlotBookingEnabled !== false)
writer.tag(29, WireType.Varint).bool(message.isSlotBookingEnabled);
/* api.SiteAlias SiteAlias = 30 [json_name = "SiteAlias"]; */
if (message.siteAlias)
SiteAlias.internalBinaryWrite(message.siteAlias, writer.tag(30, WireType.LengthDelimited).fork(), options).join();
/* api.ActorAuthorisation AppointmentConstraints = 31 [json_name = "AppointmentConstraints"]; */
if (message.appointmentConstraints)
ActorAuthorisation.internalBinaryWrite(message.appointmentConstraints, writer.tag(31, WireType.LengthDelimited).fork(), options).join();
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

351
appointment.ts Normal file
View File

@@ -0,0 +1,351 @@
// @generated by protobuf-ts 2.9.6
// @generated from protobuf file "appointment.proto" (package "api", syntax proto3)
// tslint:disable
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import { WireType } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { AppointmentStatusStruct } from "./collabShared";
import { Slot } from "./slotbooking";
import { CarrierInformation } from "./slotbooking";
import { Segmentation } from "./slotbooking";
import { QuantityByUnit } from "./slotbooking";
import { Commission } from "./collabShared";
import { AppointmentType } from "./slotbooking";
import { EntityID } from "./shared";
import { EventHeader } from "./shared";
// _common_
// import "visibility.proto";
/**
*
* Aggregation object message
*
* @generated from protobuf message api.Appointment
*/
export interface Appointment {
/**
* @generated from protobuf field: api.EventHeader LastEventHeader = 1 [json_name = "LastEventHeader"];
*/
lastEventHeader?: EventHeader;
/**
* @generated from protobuf field: api.EntityID ID = 2 [json_name = "ID"];
*/
iD?: EntityID;
/**
* @generated from protobuf field: api.AppointmentPayload Payload = 3 [json_name = "Payload"];
*/
payload?: AppointmentPayload;
}
/**
* @generated from protobuf message api.AppointmentPayload
*/
export interface AppointmentPayload {
/**
* Type of appointment : Expedition / Reception / Both
*
* @generated from protobuf field: api.AppointmentType AppointmentType = 1 [json_name = "AppointmentType"];
*/
appointmentType: AppointmentType;
/**
* List of the orders and projects for which the appointment is made, with the quantities
* TODO ??
*
* @generated from protobuf field: repeated api.Commission Commissions = 2 [json_name = "Commissions"];
*/
commissions: Commission[];
/**
* Cumulative quantity for all the commissions
*
* @generated from protobuf field: repeated api.QuantityByUnit QuantitiesByUnits = 3 [json_name = "QuantitiesByUnits"];
*/
quantitiesByUnits: QuantityByUnit[];
/**
* Set of segmentation constraining the slot booking
*
* @generated from protobuf field: repeated api.Segmentation Segmentations = 4 [json_name = "Segmentations"];
*/
segmentations: Segmentation[];
/**
* Required carrierInformation, some can be obligatory
*
* @generated from protobuf field: repeated api.CarrierInformation CarrierInformation = 5 [json_name = "CarrierInformation"];
*/
carrierInformation: CarrierInformation[];
/**
* The slot booked for the appointment
*
* @generated from protobuf field: api.Slot Slot = 6 [json_name = "Slot"];
*/
slot?: Slot;
/**
* User mails being notified on this appointment
* TODO Need to add a structure to store platform user identifiers which can act on this appointment ?
*
* @generated from protobuf field: repeated string Emails = 7 [json_name = "Emails"];
*/
emails: string[];
/**
* Appointment Status and status history
*
* @generated from protobuf field: api.AppointmentStatusStruct Status = 8 [json_name = "Status"];
*/
status?: AppointmentStatusStruct;
/**
* Creation date of the appointment
*
* @generated from protobuf field: string CreationDate = 9 [json_name = "CreationDate"];
*/
creationDate: string;
}
/**
* @generated from protobuf message api.AppointmentTriplet
*/
export interface AppointmentTriplet {
/**
* @generated from protobuf field: api.Appointment Current = 1 [json_name = "Current"];
*/
current?: Appointment;
/**
* @generated from protobuf field: api.Appointment Previous = 2 [json_name = "Previous"];
*/
previous?: Appointment;
/**
* @generated from protobuf field: api.Appointment LastEvent = 3 [json_name = "LastEvent"];
*/
lastEvent?: Appointment;
}
// @generated message type with reflection information, may provide speed optimized methods
class Appointment$Type extends MessageType<Appointment> {
constructor() {
super("api.Appointment", [
{ no: 1, name: "LastEventHeader", kind: "message", jsonName: "LastEventHeader", T: () => EventHeader },
{ no: 2, name: "ID", kind: "message", jsonName: "ID", T: () => EntityID },
{ no: 3, name: "Payload", kind: "message", jsonName: "Payload", T: () => AppointmentPayload }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { description: "Aggregation object message" } } });
}
create(value?: PartialMessage<Appointment>): Appointment {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<Appointment>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Appointment): Appointment {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.EventHeader LastEventHeader = 1 [json_name = "LastEventHeader"];*/ 1:
message.lastEventHeader = EventHeader.internalBinaryRead(reader, reader.uint32(), options, message.lastEventHeader);
break;
case /* api.EntityID ID = 2 [json_name = "ID"];*/ 2:
message.iD = EntityID.internalBinaryRead(reader, reader.uint32(), options, message.iD);
break;
case /* api.AppointmentPayload Payload = 3 [json_name = "Payload"];*/ 3:
message.payload = AppointmentPayload.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: Appointment, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.EventHeader LastEventHeader = 1 [json_name = "LastEventHeader"]; */
if (message.lastEventHeader)
EventHeader.internalBinaryWrite(message.lastEventHeader, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.EntityID ID = 2 [json_name = "ID"]; */
if (message.iD)
EntityID.internalBinaryWrite(message.iD, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.AppointmentPayload Payload = 3 [json_name = "Payload"]; */
if (message.payload)
AppointmentPayload.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.Appointment
*/
export const Appointment = new Appointment$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentPayload$Type extends MessageType<AppointmentPayload> {
constructor() {
super("api.AppointmentPayload", [
{ no: 1, name: "AppointmentType", kind: "enum", jsonName: "AppointmentType", T: () => ["api.AppointmentType", AppointmentType] },
{ no: 2, name: "Commissions", kind: "message", jsonName: "Commissions", repeat: 1 /*RepeatType.PACKED*/, T: () => Commission },
{ no: 3, name: "QuantitiesByUnits", kind: "message", jsonName: "QuantitiesByUnits", repeat: 1 /*RepeatType.PACKED*/, T: () => QuantityByUnit },
{ no: 4, name: "Segmentations", kind: "message", jsonName: "Segmentations", repeat: 1 /*RepeatType.PACKED*/, T: () => Segmentation },
{ no: 5, name: "CarrierInformation", kind: "message", jsonName: "CarrierInformation", repeat: 1 /*RepeatType.PACKED*/, T: () => CarrierInformation },
{ no: 6, name: "Slot", kind: "message", jsonName: "Slot", T: () => Slot },
{ no: 7, name: "Emails", kind: "scalar", jsonName: "Emails", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { repeated: { minItems: "1", items: { string: { email: true, ignoreEmpty: true } } } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Must be a valid email address", example: "[\"John.doe@reflex.com\", \"will.smith@reflex.com\"]" } } },
{ no: 8, name: "Status", kind: "message", jsonName: "Status", T: () => AppointmentStatusStruct, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Status of the appointment" }, "api.aggSkip": "StatusUpdated" } },
{ no: 9, name: "CreationDate", kind: "scalar", jsonName: "CreationDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { dateIso8601: true } }, "api.viewType": { Types: [{ Context: "*", Type: "date" }] } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Segmentations"] } } });
}
create(value?: PartialMessage<AppointmentPayload>): AppointmentPayload {
const message = globalThis.Object.create((this.messagePrototype!));
message.appointmentType = 0;
message.commissions = [];
message.quantitiesByUnits = [];
message.segmentations = [];
message.carrierInformation = [];
message.emails = [];
message.creationDate = "";
if (value !== undefined)
reflectionMergePartial<AppointmentPayload>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentPayload): AppointmentPayload {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.AppointmentType AppointmentType = 1 [json_name = "AppointmentType"];*/ 1:
message.appointmentType = reader.int32();
break;
case /* repeated api.Commission Commissions = 2 [json_name = "Commissions"];*/ 2:
message.commissions.push(Commission.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* repeated api.QuantityByUnit QuantitiesByUnits = 3 [json_name = "QuantitiesByUnits"];*/ 3:
message.quantitiesByUnits.push(QuantityByUnit.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* repeated api.Segmentation Segmentations = 4 [json_name = "Segmentations"];*/ 4:
message.segmentations.push(Segmentation.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* repeated api.CarrierInformation CarrierInformation = 5 [json_name = "CarrierInformation"];*/ 5:
message.carrierInformation.push(CarrierInformation.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* api.Slot Slot = 6 [json_name = "Slot"];*/ 6:
message.slot = Slot.internalBinaryRead(reader, reader.uint32(), options, message.slot);
break;
case /* repeated string Emails = 7 [json_name = "Emails"];*/ 7:
message.emails.push(reader.string());
break;
case /* api.AppointmentStatusStruct Status = 8 [json_name = "Status"];*/ 8:
message.status = AppointmentStatusStruct.internalBinaryRead(reader, reader.uint32(), options, message.status);
break;
case /* string CreationDate = 9 [json_name = "CreationDate"];*/ 9:
message.creationDate = reader.string();
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: AppointmentPayload, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.AppointmentType AppointmentType = 1 [json_name = "AppointmentType"]; */
if (message.appointmentType !== 0)
writer.tag(1, WireType.Varint).int32(message.appointmentType);
/* repeated api.Commission Commissions = 2 [json_name = "Commissions"]; */
for (let i = 0; i < message.commissions.length; i++)
Commission.internalBinaryWrite(message.commissions[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* repeated api.QuantityByUnit QuantitiesByUnits = 3 [json_name = "QuantitiesByUnits"]; */
for (let i = 0; i < message.quantitiesByUnits.length; i++)
QuantityByUnit.internalBinaryWrite(message.quantitiesByUnits[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
/* repeated api.Segmentation Segmentations = 4 [json_name = "Segmentations"]; */
for (let i = 0; i < message.segmentations.length; i++)
Segmentation.internalBinaryWrite(message.segmentations[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
/* repeated api.CarrierInformation CarrierInformation = 5 [json_name = "CarrierInformation"]; */
for (let i = 0; i < message.carrierInformation.length; i++)
CarrierInformation.internalBinaryWrite(message.carrierInformation[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
/* api.Slot Slot = 6 [json_name = "Slot"]; */
if (message.slot)
Slot.internalBinaryWrite(message.slot, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
/* repeated string Emails = 7 [json_name = "Emails"]; */
for (let i = 0; i < message.emails.length; i++)
writer.tag(7, WireType.LengthDelimited).string(message.emails[i]);
/* api.AppointmentStatusStruct Status = 8 [json_name = "Status"]; */
if (message.status)
AppointmentStatusStruct.internalBinaryWrite(message.status, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
/* string CreationDate = 9 [json_name = "CreationDate"]; */
if (message.creationDate !== "")
writer.tag(9, WireType.LengthDelimited).string(message.creationDate);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.AppointmentPayload
*/
export const AppointmentPayload = new AppointmentPayload$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentTriplet$Type extends MessageType<AppointmentTriplet> {
constructor() {
super("api.AppointmentTriplet", [
{ no: 1, name: "Current", kind: "message", jsonName: "Current", T: () => Appointment },
{ no: 2, name: "Previous", kind: "message", jsonName: "Previous", T: () => Appointment },
{ no: 3, name: "LastEvent", kind: "message", jsonName: "LastEvent", T: () => Appointment }
]);
}
create(value?: PartialMessage<AppointmentTriplet>): AppointmentTriplet {
const message = globalThis.Object.create((this.messagePrototype!));
if (value !== undefined)
reflectionMergePartial<AppointmentTriplet>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentTriplet): AppointmentTriplet {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.Appointment Current = 1 [json_name = "Current"];*/ 1:
message.current = Appointment.internalBinaryRead(reader, reader.uint32(), options, message.current);
break;
case /* api.Appointment Previous = 2 [json_name = "Previous"];*/ 2:
message.previous = Appointment.internalBinaryRead(reader, reader.uint32(), options, message.previous);
break;
case /* api.Appointment LastEvent = 3 [json_name = "LastEvent"];*/ 3:
message.lastEvent = Appointment.internalBinaryRead(reader, reader.uint32(), options, message.lastEvent);
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: AppointmentTriplet, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.Appointment Current = 1 [json_name = "Current"]; */
if (message.current)
Appointment.internalBinaryWrite(message.current, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* api.Appointment Previous = 2 [json_name = "Previous"]; */
if (message.previous)
Appointment.internalBinaryWrite(message.previous, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* api.Appointment LastEvent = 3 [json_name = "LastEvent"]; */
if (message.lastEvent)
Appointment.internalBinaryWrite(message.lastEvent, 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.AppointmentTriplet
*/
export const AppointmentTriplet = new AppointmentTriplet$Type();

160
appointmentInput.client.ts Normal file
View File

@@ -0,0 +1,160 @@
// @generated by protobuf-ts 2.9.6
// @generated from protobuf file "appointmentInput.proto" (package "api", syntax proto3)
// tslint:disable
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { AppointmentInputAPI } from "./appointmentInput";
import type { AppointmentCarrierDepartedResponse } from "./appointmentInput";
import type { AppointmentCarrierDepartedRequest } from "./appointmentInput";
import type { AppointmentReceptionUnloadedResponse } from "./appointmentInput";
import type { AppointmentReceptionUnloadedRequest } from "./appointmentInput";
import type { AppointmentReceptionStartedResponse } from "./appointmentInput";
import type { AppointmentReceptionStartedRequest } from "./appointmentInput";
import type { AppointmentExpeditionLoadedResponse } from "./appointmentInput";
import type { AppointmentExpeditionLoadedRequest } from "./appointmentInput";
import type { AppointmentExpeditionStartedResponse } from "./appointmentInput";
import type { AppointmentExpeditionStartedRequest } from "./appointmentInput";
import type { AppointmentCarrierArrivedResponse } from "./appointmentInput";
import type { AppointmentCarrierArrivedRequest } from "./appointmentInput";
import type { AppointmentCarrierExpectedResponse } from "./appointmentInput";
import type { AppointmentCarrierExpectedRequest } from "./appointmentInput";
import type { AppointmentCarrierInformationUpdatedResponse } from "./appointmentInput";
import type { AppointmentCarrierInformationUpdatedRequest } from "./appointmentInput";
import type { AppointmentCanceledResponse } from "./appointmentInput";
import type { AppointmentCanceledRequest } from "./appointmentInput";
import { stackIntercept } from "@protobuf-ts/runtime-rpc";
import type { AppointmentCreatedResponse } from "./appointmentInput";
import type { AppointmentCreatedRequest } from "./appointmentInput";
import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
/**
*
* API-server services
*
* @generated from protobuf service api.AppointmentInputAPI
*/
export interface IAppointmentInputAPIClient {
/**
* @generated from protobuf rpc: Created(api.AppointmentCreatedRequest) returns (api.AppointmentCreatedResponse);
*/
created(input: AppointmentCreatedRequest, options?: RpcOptions): UnaryCall<AppointmentCreatedRequest, AppointmentCreatedResponse>;
/**
* @generated from protobuf rpc: Canceled(api.AppointmentCanceledRequest) returns (api.AppointmentCanceledResponse);
*/
canceled(input: AppointmentCanceledRequest, options?: RpcOptions): UnaryCall<AppointmentCanceledRequest, AppointmentCanceledResponse>;
/**
* @generated from protobuf rpc: CarrierInformationUpdated(api.AppointmentCarrierInformationUpdatedRequest) returns (api.AppointmentCarrierInformationUpdatedResponse);
*/
carrierInformationUpdated(input: AppointmentCarrierInformationUpdatedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierInformationUpdatedRequest, AppointmentCarrierInformationUpdatedResponse>;
/**
* @generated from protobuf rpc: CarrierExpected(api.AppointmentCarrierExpectedRequest) returns (api.AppointmentCarrierExpectedResponse);
*/
carrierExpected(input: AppointmentCarrierExpectedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierExpectedRequest, AppointmentCarrierExpectedResponse>;
/**
* @generated from protobuf rpc: CarrierArrived(api.AppointmentCarrierArrivedRequest) returns (api.AppointmentCarrierArrivedResponse);
*/
carrierArrived(input: AppointmentCarrierArrivedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierArrivedRequest, AppointmentCarrierArrivedResponse>;
/**
* @generated from protobuf rpc: ExpeditionStarted(api.AppointmentExpeditionStartedRequest) returns (api.AppointmentExpeditionStartedResponse);
*/
expeditionStarted(input: AppointmentExpeditionStartedRequest, options?: RpcOptions): UnaryCall<AppointmentExpeditionStartedRequest, AppointmentExpeditionStartedResponse>;
/**
* @generated from protobuf rpc: ExpeditionLoaded(api.AppointmentExpeditionLoadedRequest) returns (api.AppointmentExpeditionLoadedResponse);
*/
expeditionLoaded(input: AppointmentExpeditionLoadedRequest, options?: RpcOptions): UnaryCall<AppointmentExpeditionLoadedRequest, AppointmentExpeditionLoadedResponse>;
/**
* @generated from protobuf rpc: ReceptionStarted(api.AppointmentReceptionStartedRequest) returns (api.AppointmentReceptionStartedResponse);
*/
receptionStarted(input: AppointmentReceptionStartedRequest, options?: RpcOptions): UnaryCall<AppointmentReceptionStartedRequest, AppointmentReceptionStartedResponse>;
/**
* @generated from protobuf rpc: ReceptionUnloaded(api.AppointmentReceptionUnloadedRequest) returns (api.AppointmentReceptionUnloadedResponse);
*/
receptionUnloaded(input: AppointmentReceptionUnloadedRequest, options?: RpcOptions): UnaryCall<AppointmentReceptionUnloadedRequest, AppointmentReceptionUnloadedResponse>;
/**
* @generated from protobuf rpc: CarrierDeparted(api.AppointmentCarrierDepartedRequest) returns (api.AppointmentCarrierDepartedResponse);
*/
carrierDeparted(input: AppointmentCarrierDepartedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierDepartedRequest, AppointmentCarrierDepartedResponse>;
}
/**
*
* API-server services
*
* @generated from protobuf service api.AppointmentInputAPI
*/
export class AppointmentInputAPIClient implements IAppointmentInputAPIClient, ServiceInfo {
typeName = AppointmentInputAPI.typeName;
methods = AppointmentInputAPI.methods;
options = AppointmentInputAPI.options;
constructor(private readonly _transport: RpcTransport) {
}
/**
* @generated from protobuf rpc: Created(api.AppointmentCreatedRequest) returns (api.AppointmentCreatedResponse);
*/
created(input: AppointmentCreatedRequest, options?: RpcOptions): UnaryCall<AppointmentCreatedRequest, AppointmentCreatedResponse> {
const method = this.methods[0], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentCreatedRequest, AppointmentCreatedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Canceled(api.AppointmentCanceledRequest) returns (api.AppointmentCanceledResponse);
*/
canceled(input: AppointmentCanceledRequest, options?: RpcOptions): UnaryCall<AppointmentCanceledRequest, AppointmentCanceledResponse> {
const method = this.methods[1], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentCanceledRequest, AppointmentCanceledResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CarrierInformationUpdated(api.AppointmentCarrierInformationUpdatedRequest) returns (api.AppointmentCarrierInformationUpdatedResponse);
*/
carrierInformationUpdated(input: AppointmentCarrierInformationUpdatedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierInformationUpdatedRequest, AppointmentCarrierInformationUpdatedResponse> {
const method = this.methods[2], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentCarrierInformationUpdatedRequest, AppointmentCarrierInformationUpdatedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CarrierExpected(api.AppointmentCarrierExpectedRequest) returns (api.AppointmentCarrierExpectedResponse);
*/
carrierExpected(input: AppointmentCarrierExpectedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierExpectedRequest, AppointmentCarrierExpectedResponse> {
const method = this.methods[3], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentCarrierExpectedRequest, AppointmentCarrierExpectedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CarrierArrived(api.AppointmentCarrierArrivedRequest) returns (api.AppointmentCarrierArrivedResponse);
*/
carrierArrived(input: AppointmentCarrierArrivedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierArrivedRequest, AppointmentCarrierArrivedResponse> {
const method = this.methods[4], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentCarrierArrivedRequest, AppointmentCarrierArrivedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ExpeditionStarted(api.AppointmentExpeditionStartedRequest) returns (api.AppointmentExpeditionStartedResponse);
*/
expeditionStarted(input: AppointmentExpeditionStartedRequest, options?: RpcOptions): UnaryCall<AppointmentExpeditionStartedRequest, AppointmentExpeditionStartedResponse> {
const method = this.methods[5], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentExpeditionStartedRequest, AppointmentExpeditionStartedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ExpeditionLoaded(api.AppointmentExpeditionLoadedRequest) returns (api.AppointmentExpeditionLoadedResponse);
*/
expeditionLoaded(input: AppointmentExpeditionLoadedRequest, options?: RpcOptions): UnaryCall<AppointmentExpeditionLoadedRequest, AppointmentExpeditionLoadedResponse> {
const method = this.methods[6], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentExpeditionLoadedRequest, AppointmentExpeditionLoadedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ReceptionStarted(api.AppointmentReceptionStartedRequest) returns (api.AppointmentReceptionStartedResponse);
*/
receptionStarted(input: AppointmentReceptionStartedRequest, options?: RpcOptions): UnaryCall<AppointmentReceptionStartedRequest, AppointmentReceptionStartedResponse> {
const method = this.methods[7], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentReceptionStartedRequest, AppointmentReceptionStartedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ReceptionUnloaded(api.AppointmentReceptionUnloadedRequest) returns (api.AppointmentReceptionUnloadedResponse);
*/
receptionUnloaded(input: AppointmentReceptionUnloadedRequest, options?: RpcOptions): UnaryCall<AppointmentReceptionUnloadedRequest, AppointmentReceptionUnloadedResponse> {
const method = this.methods[8], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentReceptionUnloadedRequest, AppointmentReceptionUnloadedResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CarrierDeparted(api.AppointmentCarrierDepartedRequest) returns (api.AppointmentCarrierDepartedResponse);
*/
carrierDeparted(input: AppointmentCarrierDepartedRequest, options?: RpcOptions): UnaryCall<AppointmentCarrierDepartedRequest, AppointmentCarrierDepartedResponse> {
const method = this.methods[9], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentCarrierDepartedRequest, AppointmentCarrierDepartedResponse>("unary", this._transport, method, opt, input);
}
}

2893
appointmentInput.ts Normal file
View File

File diff suppressed because it is too large Load Diff

115
appointmentQuery.client.ts Normal file
View File

@@ -0,0 +1,115 @@
// @generated by protobuf-ts 2.9.6
// @generated from protobuf file "appointmentQuery.proto" (package "api", syntax proto3)
// tslint:disable
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { AppointmentQuery } from "./appointmentQuery";
import type { CountLinesResult } from "./shared";
import type { CountLinesQuery } from "./shared";
import type { GetKPIDataResult } from "./clickhouse";
import type { GetKPIDataQuery } from "./clickhouse";
import type { ExtractResult } from "./shared";
import type { ExtractQuery } from "./shared";
import type { ElementByMatchResult } from "./shared";
import type { ElementByMatchQuery } from "./shared";
import type { AppointmentByMatchResult } from "./appointmentQuery";
import type { AppointmentByMatchQuery } from "./appointmentQuery";
import type { AppointmentByFilterResult } from "./appointmentQuery";
import type { AppointmentByFilterQuery } from "./appointmentQuery";
import { stackIntercept } from "@protobuf-ts/runtime-rpc";
import type { AppointmentByIdResult } from "./appointmentQuery";
import type { AppointmentByIdQuery } from "./appointmentQuery";
import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
/**
* @generated from protobuf service api.AppointmentQuery
*/
export interface IAppointmentQueryClient {
/**
* @generated from protobuf rpc: GetByIds(api.AppointmentByIdQuery) returns (api.AppointmentByIdResult);
*/
getByIds(input: AppointmentByIdQuery, options?: RpcOptions): UnaryCall<AppointmentByIdQuery, AppointmentByIdResult>;
/**
* @generated from protobuf rpc: Find(api.AppointmentByFilterQuery) returns (api.AppointmentByFilterResult);
*/
find(input: AppointmentByFilterQuery, options?: RpcOptions): UnaryCall<AppointmentByFilterQuery, AppointmentByFilterResult>;
/**
* @generated from protobuf rpc: FindMatchingFieldValues(api.AppointmentByMatchQuery) returns (api.AppointmentByMatchResult);
*/
findMatchingFieldValues(input: AppointmentByMatchQuery, options?: RpcOptions): UnaryCall<AppointmentByMatchQuery, AppointmentByMatchResult>;
/**
* @generated from protobuf rpc: FindMatchingFieldElements(api.ElementByMatchQuery) returns (api.ElementByMatchResult);
*/
findMatchingFieldElements(input: ElementByMatchQuery, options?: RpcOptions): UnaryCall<ElementByMatchQuery, ElementByMatchResult>;
/**
* @generated from protobuf rpc: Extract(api.ExtractQuery) returns (api.ExtractResult);
*/
extract(input: ExtractQuery, options?: RpcOptions): UnaryCall<ExtractQuery, ExtractResult>;
/**
* @generated from protobuf rpc: GetKPIData(api.GetKPIDataQuery) returns (api.GetKPIDataResult);
*/
getKPIData(input: GetKPIDataQuery, options?: RpcOptions): UnaryCall<GetKPIDataQuery, GetKPIDataResult>;
/**
* @generated from protobuf rpc: CountLines(api.CountLinesQuery) returns (api.CountLinesResult);
*/
countLines(input: CountLinesQuery, options?: RpcOptions): UnaryCall<CountLinesQuery, CountLinesResult>;
}
/**
* @generated from protobuf service api.AppointmentQuery
*/
export class AppointmentQueryClient implements IAppointmentQueryClient, ServiceInfo {
typeName = AppointmentQuery.typeName;
methods = AppointmentQuery.methods;
options = AppointmentQuery.options;
constructor(private readonly _transport: RpcTransport) {
}
/**
* @generated from protobuf rpc: GetByIds(api.AppointmentByIdQuery) returns (api.AppointmentByIdResult);
*/
getByIds(input: AppointmentByIdQuery, options?: RpcOptions): UnaryCall<AppointmentByIdQuery, AppointmentByIdResult> {
const method = this.methods[0], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentByIdQuery, AppointmentByIdResult>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Find(api.AppointmentByFilterQuery) returns (api.AppointmentByFilterResult);
*/
find(input: AppointmentByFilterQuery, options?: RpcOptions): UnaryCall<AppointmentByFilterQuery, AppointmentByFilterResult> {
const method = this.methods[1], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentByFilterQuery, AppointmentByFilterResult>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: FindMatchingFieldValues(api.AppointmentByMatchQuery) returns (api.AppointmentByMatchResult);
*/
findMatchingFieldValues(input: AppointmentByMatchQuery, options?: RpcOptions): UnaryCall<AppointmentByMatchQuery, AppointmentByMatchResult> {
const method = this.methods[2], opt = this._transport.mergeOptions(options);
return stackIntercept<AppointmentByMatchQuery, AppointmentByMatchResult>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: FindMatchingFieldElements(api.ElementByMatchQuery) returns (api.ElementByMatchResult);
*/
findMatchingFieldElements(input: ElementByMatchQuery, options?: RpcOptions): UnaryCall<ElementByMatchQuery, ElementByMatchResult> {
const method = this.methods[3], opt = this._transport.mergeOptions(options);
return stackIntercept<ElementByMatchQuery, ElementByMatchResult>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Extract(api.ExtractQuery) returns (api.ExtractResult);
*/
extract(input: ExtractQuery, options?: RpcOptions): UnaryCall<ExtractQuery, ExtractResult> {
const method = this.methods[4], opt = this._transport.mergeOptions(options);
return stackIntercept<ExtractQuery, ExtractResult>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: GetKPIData(api.GetKPIDataQuery) returns (api.GetKPIDataResult);
*/
getKPIData(input: GetKPIDataQuery, options?: RpcOptions): UnaryCall<GetKPIDataQuery, GetKPIDataResult> {
const method = this.methods[5], opt = this._transport.mergeOptions(options);
return stackIntercept<GetKPIDataQuery, GetKPIDataResult>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CountLines(api.CountLinesQuery) returns (api.CountLinesResult);
*/
countLines(input: CountLinesQuery, options?: RpcOptions): UnaryCall<CountLinesQuery, CountLinesResult> {
const method = this.methods[6], opt = this._transport.mergeOptions(options);
return stackIntercept<CountLinesQuery, CountLinesResult>("unary", this._transport, method, opt, input);
}
}

490
appointmentQuery.ts Normal file
View File

@@ -0,0 +1,490 @@
// @generated by protobuf-ts 2.9.6
// @generated from protobuf file "appointmentQuery.proto" (package "api", syntax proto3)
// tslint:disable
import { CountLinesResult } from "./shared";
import { CountLinesQuery } from "./shared";
import { GetKPIDataResult } from "./clickhouse";
import { GetKPIDataQuery } from "./clickhouse";
import { ExtractResult } from "./shared";
import { ExtractQuery } from "./shared";
import { ElementByMatchResult } from "./shared";
import { ElementByMatchQuery } from "./shared";
import { ServiceType } from "@protobuf-ts/runtime-rpc";
import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
import type { IBinaryWriter } from "@protobuf-ts/runtime";
import { WireType } from "@protobuf-ts/runtime";
import type { BinaryReadOptions } from "@protobuf-ts/runtime";
import type { IBinaryReader } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { MatchFieldResult } from "./shared";
import { MatchField } from "./shared";
import { BlockFilter } from "./shared";
import { Appointment } from "./appointment";
import { ResultHeader } from "./shared";
import { EntityID } from "./shared";
import { QueryProjectHeader } from "./shared";
//
// Query-server services
/**
* @generated from protobuf message api.AppointmentByIdQuery
*/
export interface AppointmentByIdQuery {
/**
* @generated from protobuf field: api.QueryProjectHeader Header = 1 [json_name = "Header"];
*/
header?: QueryProjectHeader;
/**
* @generated from protobuf field: repeated api.EntityID IDs = 2 [json_name = "IDs"];
*/
iDs: EntityID[];
}
/**
* @generated from protobuf message api.AppointmentByIdResult
*/
export interface AppointmentByIdResult {
/**
* @generated from protobuf field: api.ResultHeader Header = 1 [json_name = "Header"];
*/
header?: ResultHeader;
/**
* @generated from protobuf field: repeated api.Appointment Objects = 2 [json_name = "Objects"];
*/
objects: Appointment[];
}
/**
* @generated from protobuf message api.AppointmentByFilterQuery
*/
export interface AppointmentByFilterQuery {
/**
* @generated from protobuf field: api.QueryProjectHeader Header = 1 [json_name = "Header"];
*/
header?: QueryProjectHeader;
/**
* Number of maximum result
*
* @generated from protobuf field: string limitFilter = 4;
*/
limitFilter: string;
/**
* @generated from protobuf field: string queryContext = 5;
*/
queryContext: string;
/**
* list of blockFilters structure for Find query, each element (BlockFilter) in the list is an "OR" part of the query, if not empty, simpleFilters (deprecated) & rangeFilters (deprecated) will be ignored
*
* @generated from protobuf field: repeated api.BlockFilter BlockFilters = 6 [json_name = "BlockFilters"];
*/
blockFilters: BlockFilter[];
}
/**
* @generated from protobuf message api.AppointmentByFilterResult
*/
export interface AppointmentByFilterResult {
/**
* @generated from protobuf field: api.ResultHeader Header = 1 [json_name = "Header"];
*/
header?: ResultHeader;
/**
* @generated from protobuf field: repeated api.Appointment Objects = 2 [json_name = "Objects"];
*/
objects: Appointment[];
/**
* @generated from protobuf field: string queryContext = 3;
*/
queryContext: string;
}
/**
* @generated from protobuf message api.AppointmentByMatchQuery
*/
export interface AppointmentByMatchQuery {
/**
* @generated from protobuf field: api.QueryProjectHeader Header = 1 [json_name = "Header"];
*/
header?: QueryProjectHeader;
/**
* list of blockFilters structure for Find query, each element (BlockFilter) in the list is an "OR" part of the query, if not empty, simpleFilters (deprecated) & rangeFilters (deprecated) will be ignored
*
* @generated from protobuf field: repeated api.BlockFilter BlockFilters = 5 [json_name = "BlockFilters"];
*/
blockFilters: BlockFilter[];
/**
* MatchField list structure, for FindMatching query
*
* @generated from protobuf field: repeated api.MatchField MatchFields = 6 [json_name = "MatchFields"];
*/
matchFields: MatchField[];
}
/**
* @generated from protobuf message api.AppointmentByMatchResult
*/
export interface AppointmentByMatchResult {
/**
* @generated from protobuf field: repeated api.MatchFieldResult MatchResults = 2 [json_name = "MatchResults"];
*/
matchResults: MatchFieldResult[];
}
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentByIdQuery$Type extends MessageType<AppointmentByIdQuery> {
constructor() {
super("api.AppointmentByIdQuery", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => QueryProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 2, name: "IDs", kind: "message", jsonName: "IDs", repeat: 1 /*RepeatType.PACKED*/, T: () => EntityID, options: { "validate.rules": { repeated: { minItems: "1" } } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header", "IDs"] } }, "api.messageType": "Query" });
}
create(value?: PartialMessage<AppointmentByIdQuery>): AppointmentByIdQuery {
const message = globalThis.Object.create((this.messagePrototype!));
message.iDs = [];
if (value !== undefined)
reflectionMergePartial<AppointmentByIdQuery>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentByIdQuery): AppointmentByIdQuery {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.QueryProjectHeader Header = 1 [json_name = "Header"];*/ 1:
message.header = QueryProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* repeated api.EntityID IDs = 2 [json_name = "IDs"];*/ 2:
message.iDs.push(EntityID.internalBinaryRead(reader, reader.uint32(), options));
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: AppointmentByIdQuery, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.QueryProjectHeader Header = 1 [json_name = "Header"]; */
if (message.header)
QueryProjectHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* repeated api.EntityID IDs = 2 [json_name = "IDs"]; */
for (let i = 0; i < message.iDs.length; i++)
EntityID.internalBinaryWrite(message.iDs[i], 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.AppointmentByIdQuery
*/
export const AppointmentByIdQuery = new AppointmentByIdQuery$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentByIdResult$Type extends MessageType<AppointmentByIdResult> {
constructor() {
super("api.AppointmentByIdResult", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => ResultHeader },
{ no: 2, name: "Objects", kind: "message", jsonName: "Objects", repeat: 1 /*RepeatType.PACKED*/, T: () => Appointment }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: {} }, "api.messageType": "Result" });
}
create(value?: PartialMessage<AppointmentByIdResult>): AppointmentByIdResult {
const message = globalThis.Object.create((this.messagePrototype!));
message.objects = [];
if (value !== undefined)
reflectionMergePartial<AppointmentByIdResult>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentByIdResult): AppointmentByIdResult {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResultHeader Header = 1 [json_name = "Header"];*/ 1:
message.header = ResultHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* repeated api.Appointment Objects = 2 [json_name = "Objects"];*/ 2:
message.objects.push(Appointment.internalBinaryRead(reader, reader.uint32(), options));
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: AppointmentByIdResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResultHeader Header = 1 [json_name = "Header"]; */
if (message.header)
ResultHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* repeated api.Appointment Objects = 2 [json_name = "Objects"]; */
for (let i = 0; i < message.objects.length; i++)
Appointment.internalBinaryWrite(message.objects[i], 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.AppointmentByIdResult
*/
export const AppointmentByIdResult = new AppointmentByIdResult$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentByFilterQuery$Type extends MessageType<AppointmentByFilterQuery> {
constructor() {
super("api.AppointmentByFilterQuery", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => QueryProjectHeader, options: { "validate.rules": { message: { required: true } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": {} } },
{ no: 4, name: "limitFilter", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Number of maximum result", example: "\"500\"" } } },
{ no: 5, name: "queryContext", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
{ no: 6, name: "BlockFilters", kind: "message", jsonName: "BlockFilters", repeat: 1 /*RepeatType.PACKED*/, T: () => BlockFilter }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
}
create(value?: PartialMessage<AppointmentByFilterQuery>): AppointmentByFilterQuery {
const message = globalThis.Object.create((this.messagePrototype!));
message.limitFilter = "";
message.queryContext = "";
message.blockFilters = [];
if (value !== undefined)
reflectionMergePartial<AppointmentByFilterQuery>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentByFilterQuery): AppointmentByFilterQuery {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.QueryProjectHeader Header = 1 [json_name = "Header"];*/ 1:
message.header = QueryProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* string limitFilter */ 4:
message.limitFilter = reader.string();
break;
case /* string queryContext */ 5:
message.queryContext = reader.string();
break;
case /* repeated api.BlockFilter BlockFilters = 6 [json_name = "BlockFilters"];*/ 6:
message.blockFilters.push(BlockFilter.internalBinaryRead(reader, reader.uint32(), options));
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: AppointmentByFilterQuery, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.QueryProjectHeader Header = 1 [json_name = "Header"]; */
if (message.header)
QueryProjectHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* string limitFilter = 4; */
if (message.limitFilter !== "")
writer.tag(4, WireType.LengthDelimited).string(message.limitFilter);
/* string queryContext = 5; */
if (message.queryContext !== "")
writer.tag(5, WireType.LengthDelimited).string(message.queryContext);
/* repeated api.BlockFilter BlockFilters = 6 [json_name = "BlockFilters"]; */
for (let i = 0; i < message.blockFilters.length; i++)
BlockFilter.internalBinaryWrite(message.blockFilters[i], writer.tag(6, 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.AppointmentByFilterQuery
*/
export const AppointmentByFilterQuery = new AppointmentByFilterQuery$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentByFilterResult$Type extends MessageType<AppointmentByFilterResult> {
constructor() {
super("api.AppointmentByFilterResult", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => ResultHeader },
{ no: 2, name: "Objects", kind: "message", jsonName: "Objects", repeat: 1 /*RepeatType.PACKED*/, T: () => Appointment },
{ no: 3, name: "queryContext", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
]);
}
create(value?: PartialMessage<AppointmentByFilterResult>): AppointmentByFilterResult {
const message = globalThis.Object.create((this.messagePrototype!));
message.objects = [];
message.queryContext = "";
if (value !== undefined)
reflectionMergePartial<AppointmentByFilterResult>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentByFilterResult): AppointmentByFilterResult {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.ResultHeader Header = 1 [json_name = "Header"];*/ 1:
message.header = ResultHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* repeated api.Appointment Objects = 2 [json_name = "Objects"];*/ 2:
message.objects.push(Appointment.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* string queryContext */ 3:
message.queryContext = reader.string();
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: AppointmentByFilterResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.ResultHeader Header = 1 [json_name = "Header"]; */
if (message.header)
ResultHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* repeated api.Appointment Objects = 2 [json_name = "Objects"]; */
for (let i = 0; i < message.objects.length; i++)
Appointment.internalBinaryWrite(message.objects[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* string queryContext = 3; */
if (message.queryContext !== "")
writer.tag(3, WireType.LengthDelimited).string(message.queryContext);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.AppointmentByFilterResult
*/
export const AppointmentByFilterResult = new AppointmentByFilterResult$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentByMatchQuery$Type extends MessageType<AppointmentByMatchQuery> {
constructor() {
super("api.AppointmentByMatchQuery", [
{ no: 1, name: "Header", kind: "message", jsonName: "Header", T: () => QueryProjectHeader, options: { "validate.rules": { message: { required: true } } } },
{ no: 5, name: "BlockFilters", kind: "message", jsonName: "BlockFilters", repeat: 1 /*RepeatType.PACKED*/, T: () => BlockFilter },
{ no: 6, name: "MatchFields", kind: "message", jsonName: "MatchFields", repeat: 1 /*RepeatType.PACKED*/, T: () => MatchField, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "MatchField list structure, for FindMatching query" } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["Header"] } } });
}
create(value?: PartialMessage<AppointmentByMatchQuery>): AppointmentByMatchQuery {
const message = globalThis.Object.create((this.messagePrototype!));
message.blockFilters = [];
message.matchFields = [];
if (value !== undefined)
reflectionMergePartial<AppointmentByMatchQuery>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentByMatchQuery): AppointmentByMatchQuery {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.QueryProjectHeader Header = 1 [json_name = "Header"];*/ 1:
message.header = QueryProjectHeader.internalBinaryRead(reader, reader.uint32(), options, message.header);
break;
case /* repeated api.BlockFilter BlockFilters = 5 [json_name = "BlockFilters"];*/ 5:
message.blockFilters.push(BlockFilter.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* repeated api.MatchField MatchFields = 6 [json_name = "MatchFields"];*/ 6:
message.matchFields.push(MatchField.internalBinaryRead(reader, reader.uint32(), options));
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: AppointmentByMatchQuery, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.QueryProjectHeader Header = 1 [json_name = "Header"]; */
if (message.header)
QueryProjectHeader.internalBinaryWrite(message.header, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* repeated api.BlockFilter BlockFilters = 5 [json_name = "BlockFilters"]; */
for (let i = 0; i < message.blockFilters.length; i++)
BlockFilter.internalBinaryWrite(message.blockFilters[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
/* repeated api.MatchField MatchFields = 6 [json_name = "MatchFields"]; */
for (let i = 0; i < message.matchFields.length; i++)
MatchField.internalBinaryWrite(message.matchFields[i], writer.tag(6, 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.AppointmentByMatchQuery
*/
export const AppointmentByMatchQuery = new AppointmentByMatchQuery$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentByMatchResult$Type extends MessageType<AppointmentByMatchResult> {
constructor() {
super("api.AppointmentByMatchResult", [
{ no: 2, name: "MatchResults", kind: "message", jsonName: "MatchResults", repeat: 1 /*RepeatType.PACKED*/, T: () => MatchFieldResult }
]);
}
create(value?: PartialMessage<AppointmentByMatchResult>): AppointmentByMatchResult {
const message = globalThis.Object.create((this.messagePrototype!));
message.matchResults = [];
if (value !== undefined)
reflectionMergePartial<AppointmentByMatchResult>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentByMatchResult): AppointmentByMatchResult {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* repeated api.MatchFieldResult MatchResults = 2 [json_name = "MatchResults"];*/ 2:
message.matchResults.push(MatchFieldResult.internalBinaryRead(reader, reader.uint32(), options));
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: AppointmentByMatchResult, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* repeated api.MatchFieldResult MatchResults = 2 [json_name = "MatchResults"]; */
for (let i = 0; i < message.matchResults.length; i++)
MatchFieldResult.internalBinaryWrite(message.matchResults[i], 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.AppointmentByMatchResult
*/
export const AppointmentByMatchResult = new AppointmentByMatchResult$Type();
/**
* @generated ServiceType for protobuf service api.AppointmentQuery
*/
export const AppointmentQuery = new ServiceType("api.AppointmentQuery", [
{ name: "GetByIds", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Query"], description: "Get Appointments from Ids" }, "api.rscType": "Site", "api.roles": "Platform.Site-Query", "api.moduleID": "appointment", "api.tableName": "appointmentById", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: AppointmentByIdQuery, O: AppointmentByIdResult },
{ name: "Find", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Query"], description: "Find Appointments using search criterias" }, "api.customQuery": true, "api.rscType": "Site", "api.roles": "Platform.Site-Query", "api.moduleID": "appointment", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: AppointmentByFilterQuery, O: AppointmentByFilterResult },
{ name: "FindMatchingFieldValues", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Query"], description: "Using search criteria & a main field word, find the list of fields containing the searched word (used for auto completion purposes ...) " }, "api.customQuery": true, "api.rscType": "Site", "api.roles": "", "api.moduleID": "appointment", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: AppointmentByMatchQuery, O: AppointmentByMatchResult },
{ name: "FindMatchingFieldElements", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Query"], description: "using search criteria & a main field word, find the list of field elements containing the searched word (used for auto completion purposes ...) " }, "api.rscType": "Site", "api.roles": "", "api.moduleID": "appointment", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ElementByMatchQuery, O: ElementByMatchResult },
{ name: "Extract", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Query"], description: "Schedule a data extraction" }, "api.rscType": "Site", "api.roles": "", "api.moduleID": "appointment", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: ExtractQuery, O: ExtractResult },
{ name: "GetKPIData", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Query"], description: "Get Appointment KPI data" }, "api.rscType": "Site", "api.roles": "", "api.moduleID": "appointment", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: GetKPIDataQuery, O: GetKPIDataResult },
{ name: "CountLines", options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation": { tags: ["Appointment Query"], description: "Count lines in database for project" }, "api.rscType": "Platform", "api.roles": "Platform.Site-Query", "api.moduleID": "appointment", "google.api.method_visibility": { restriction: "PUBLIC" } }, I: CountLinesQuery, O: CountLinesResult }
], { "api.serviceType": "Query", "api.k8sService": "collab-query-server" });

206
calendar.client.ts Normal file
View File

@@ -0,0 +1,206 @@
// @generated by protobuf-ts 2.9.6
// @generated from protobuf file "calendar.proto" (package "api", syntax proto3)
// tslint:disable
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { CalendarService } from "./calendar";
import type { CloneCalendarOnSiteResponse } from "./calendar";
import type { CloneCalendarOnSiteRequest } from "./calendar";
import type { ImportClassicHolidaysOnSiteResponse } from "./calendar";
import type { ImportClassicHolidaysOnSiteRequest } from "./calendar";
import type { DeleteCalendarOnSiteResponse } from "./calendar";
import type { DeleteCalendarOnSiteRequest } from "./calendar";
import type { UpdateCalendarOnSiteResponse } from "./calendar";
import type { UpdateCalendarOnSiteRequest } from "./calendar";
import type { ListCalendarOnSiteResponse } from "./calendar";
import type { ListCalendarOnSiteRequest } from "./calendar";
import type { GetCalendarOnSiteResponse } from "./calendar";
import type { GetCalendarOnSiteRequest } from "./calendar";
import type { CreateCalendarOnSiteResponse } from "./calendar";
import type { CreateCalendarOnSiteRequest } from "./calendar";
import type { CloneCalendarOnOrganisationResponse } from "./calendar";
import type { CloneCalendarOnOrganisationRequest } from "./calendar";
import type { ImportClassicHolidaysOnOrganisationResponse } from "./calendar";
import type { ImportClassicHolidaysOnOrganisationRequest } from "./calendar";
import type { DeleteCalendarOnOrganisationResponse } from "./calendar";
import type { DeleteCalendarOnOrganisationRequest } from "./calendar";
import type { UpdateCalendarOnOrganisationResponse } from "./calendar";
import type { UpdateCalendarOnOrganisationRequest } from "./calendar";
import type { ListCalendarOnOrganisationResponse } from "./calendar";
import type { ListCalendarOnOrganisationRequest } from "./calendar";
import type { GetCalendarOnOrganisationResponse } from "./calendar";
import type { GetCalendarOnOrganisationRequest } from "./calendar";
import { stackIntercept } from "@protobuf-ts/runtime-rpc";
import type { CreateCalendarOnOrganisationResponse } from "./calendar";
import type { CreateCalendarOnOrganisationRequest } from "./calendar";
import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
/**
* @generated from protobuf service api.CalendarService
*/
export interface ICalendarServiceClient {
/**
* @generated from protobuf rpc: CreateCalendarOnOrganisation(api.CreateCalendarOnOrganisationRequest) returns (api.CreateCalendarOnOrganisationResponse);
*/
createCalendarOnOrganisation(input: CreateCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<CreateCalendarOnOrganisationRequest, CreateCalendarOnOrganisationResponse>;
/**
* @generated from protobuf rpc: GetCalendarOnOrganisation(api.GetCalendarOnOrganisationRequest) returns (api.GetCalendarOnOrganisationResponse);
*/
getCalendarOnOrganisation(input: GetCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<GetCalendarOnOrganisationRequest, GetCalendarOnOrganisationResponse>;
/**
* @generated from protobuf rpc: ListCalendarOnOrganisation(api.ListCalendarOnOrganisationRequest) returns (api.ListCalendarOnOrganisationResponse);
*/
listCalendarOnOrganisation(input: ListCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<ListCalendarOnOrganisationRequest, ListCalendarOnOrganisationResponse>;
/**
* @generated from protobuf rpc: UpdateCalendarOnOrganisation(api.UpdateCalendarOnOrganisationRequest) returns (api.UpdateCalendarOnOrganisationResponse);
*/
updateCalendarOnOrganisation(input: UpdateCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<UpdateCalendarOnOrganisationRequest, UpdateCalendarOnOrganisationResponse>;
/**
* @generated from protobuf rpc: DeleteCalendarOnOrganisation(api.DeleteCalendarOnOrganisationRequest) returns (api.DeleteCalendarOnOrganisationResponse);
*/
deleteCalendarOnOrganisation(input: DeleteCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<DeleteCalendarOnOrganisationRequest, DeleteCalendarOnOrganisationResponse>;
/**
* @generated from protobuf rpc: ImportClassicHolidaysOnOrganisation(api.ImportClassicHolidaysOnOrganisationRequest) returns (api.ImportClassicHolidaysOnOrganisationResponse);
*/
importClassicHolidaysOnOrganisation(input: ImportClassicHolidaysOnOrganisationRequest, options?: RpcOptions): UnaryCall<ImportClassicHolidaysOnOrganisationRequest, ImportClassicHolidaysOnOrganisationResponse>;
/**
* @generated from protobuf rpc: CloneCalendarOnOrganisation(api.CloneCalendarOnOrganisationRequest) returns (api.CloneCalendarOnOrganisationResponse);
*/
cloneCalendarOnOrganisation(input: CloneCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<CloneCalendarOnOrganisationRequest, CloneCalendarOnOrganisationResponse>;
/**
* @generated from protobuf rpc: CreateCalendarOnSite(api.CreateCalendarOnSiteRequest) returns (api.CreateCalendarOnSiteResponse);
*/
createCalendarOnSite(input: CreateCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<CreateCalendarOnSiteRequest, CreateCalendarOnSiteResponse>;
/**
* @generated from protobuf rpc: GetCalendarOnSite(api.GetCalendarOnSiteRequest) returns (api.GetCalendarOnSiteResponse);
*/
getCalendarOnSite(input: GetCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<GetCalendarOnSiteRequest, GetCalendarOnSiteResponse>;
/**
* @generated from protobuf rpc: ListCalendarOnSite(api.ListCalendarOnSiteRequest) returns (api.ListCalendarOnSiteResponse);
*/
listCalendarOnSite(input: ListCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<ListCalendarOnSiteRequest, ListCalendarOnSiteResponse>;
/**
* @generated from protobuf rpc: UpdateCalendarOnSite(api.UpdateCalendarOnSiteRequest) returns (api.UpdateCalendarOnSiteResponse);
*/
updateCalendarOnSite(input: UpdateCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<UpdateCalendarOnSiteRequest, UpdateCalendarOnSiteResponse>;
/**
* @generated from protobuf rpc: DeleteCalendarOnSite(api.DeleteCalendarOnSiteRequest) returns (api.DeleteCalendarOnSiteResponse);
*/
deleteCalendarOnSite(input: DeleteCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<DeleteCalendarOnSiteRequest, DeleteCalendarOnSiteResponse>;
/**
* @generated from protobuf rpc: ImportClassicHolidaysOnSite(api.ImportClassicHolidaysOnSiteRequest) returns (api.ImportClassicHolidaysOnSiteResponse);
*/
importClassicHolidaysOnSite(input: ImportClassicHolidaysOnSiteRequest, options?: RpcOptions): UnaryCall<ImportClassicHolidaysOnSiteRequest, ImportClassicHolidaysOnSiteResponse>;
/**
* @generated from protobuf rpc: CloneCalendarOnSite(api.CloneCalendarOnSiteRequest) returns (api.CloneCalendarOnSiteResponse);
*/
cloneCalendarOnSite(input: CloneCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<CloneCalendarOnSiteRequest, CloneCalendarOnSiteResponse>;
}
/**
* @generated from protobuf service api.CalendarService
*/
export class CalendarServiceClient implements ICalendarServiceClient, ServiceInfo {
typeName = CalendarService.typeName;
methods = CalendarService.methods;
options = CalendarService.options;
constructor(private readonly _transport: RpcTransport) {
}
/**
* @generated from protobuf rpc: CreateCalendarOnOrganisation(api.CreateCalendarOnOrganisationRequest) returns (api.CreateCalendarOnOrganisationResponse);
*/
createCalendarOnOrganisation(input: CreateCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<CreateCalendarOnOrganisationRequest, CreateCalendarOnOrganisationResponse> {
const method = this.methods[0], opt = this._transport.mergeOptions(options);
return stackIntercept<CreateCalendarOnOrganisationRequest, CreateCalendarOnOrganisationResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: GetCalendarOnOrganisation(api.GetCalendarOnOrganisationRequest) returns (api.GetCalendarOnOrganisationResponse);
*/
getCalendarOnOrganisation(input: GetCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<GetCalendarOnOrganisationRequest, GetCalendarOnOrganisationResponse> {
const method = this.methods[1], opt = this._transport.mergeOptions(options);
return stackIntercept<GetCalendarOnOrganisationRequest, GetCalendarOnOrganisationResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ListCalendarOnOrganisation(api.ListCalendarOnOrganisationRequest) returns (api.ListCalendarOnOrganisationResponse);
*/
listCalendarOnOrganisation(input: ListCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<ListCalendarOnOrganisationRequest, ListCalendarOnOrganisationResponse> {
const method = this.methods[2], opt = this._transport.mergeOptions(options);
return stackIntercept<ListCalendarOnOrganisationRequest, ListCalendarOnOrganisationResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: UpdateCalendarOnOrganisation(api.UpdateCalendarOnOrganisationRequest) returns (api.UpdateCalendarOnOrganisationResponse);
*/
updateCalendarOnOrganisation(input: UpdateCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<UpdateCalendarOnOrganisationRequest, UpdateCalendarOnOrganisationResponse> {
const method = this.methods[3], opt = this._transport.mergeOptions(options);
return stackIntercept<UpdateCalendarOnOrganisationRequest, UpdateCalendarOnOrganisationResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: DeleteCalendarOnOrganisation(api.DeleteCalendarOnOrganisationRequest) returns (api.DeleteCalendarOnOrganisationResponse);
*/
deleteCalendarOnOrganisation(input: DeleteCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<DeleteCalendarOnOrganisationRequest, DeleteCalendarOnOrganisationResponse> {
const method = this.methods[4], opt = this._transport.mergeOptions(options);
return stackIntercept<DeleteCalendarOnOrganisationRequest, DeleteCalendarOnOrganisationResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ImportClassicHolidaysOnOrganisation(api.ImportClassicHolidaysOnOrganisationRequest) returns (api.ImportClassicHolidaysOnOrganisationResponse);
*/
importClassicHolidaysOnOrganisation(input: ImportClassicHolidaysOnOrganisationRequest, options?: RpcOptions): UnaryCall<ImportClassicHolidaysOnOrganisationRequest, ImportClassicHolidaysOnOrganisationResponse> {
const method = this.methods[5], opt = this._transport.mergeOptions(options);
return stackIntercept<ImportClassicHolidaysOnOrganisationRequest, ImportClassicHolidaysOnOrganisationResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CloneCalendarOnOrganisation(api.CloneCalendarOnOrganisationRequest) returns (api.CloneCalendarOnOrganisationResponse);
*/
cloneCalendarOnOrganisation(input: CloneCalendarOnOrganisationRequest, options?: RpcOptions): UnaryCall<CloneCalendarOnOrganisationRequest, CloneCalendarOnOrganisationResponse> {
const method = this.methods[6], opt = this._transport.mergeOptions(options);
return stackIntercept<CloneCalendarOnOrganisationRequest, CloneCalendarOnOrganisationResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CreateCalendarOnSite(api.CreateCalendarOnSiteRequest) returns (api.CreateCalendarOnSiteResponse);
*/
createCalendarOnSite(input: CreateCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<CreateCalendarOnSiteRequest, CreateCalendarOnSiteResponse> {
const method = this.methods[7], opt = this._transport.mergeOptions(options);
return stackIntercept<CreateCalendarOnSiteRequest, CreateCalendarOnSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: GetCalendarOnSite(api.GetCalendarOnSiteRequest) returns (api.GetCalendarOnSiteResponse);
*/
getCalendarOnSite(input: GetCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<GetCalendarOnSiteRequest, GetCalendarOnSiteResponse> {
const method = this.methods[8], opt = this._transport.mergeOptions(options);
return stackIntercept<GetCalendarOnSiteRequest, GetCalendarOnSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ListCalendarOnSite(api.ListCalendarOnSiteRequest) returns (api.ListCalendarOnSiteResponse);
*/
listCalendarOnSite(input: ListCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<ListCalendarOnSiteRequest, ListCalendarOnSiteResponse> {
const method = this.methods[9], opt = this._transport.mergeOptions(options);
return stackIntercept<ListCalendarOnSiteRequest, ListCalendarOnSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: UpdateCalendarOnSite(api.UpdateCalendarOnSiteRequest) returns (api.UpdateCalendarOnSiteResponse);
*/
updateCalendarOnSite(input: UpdateCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<UpdateCalendarOnSiteRequest, UpdateCalendarOnSiteResponse> {
const method = this.methods[10], opt = this._transport.mergeOptions(options);
return stackIntercept<UpdateCalendarOnSiteRequest, UpdateCalendarOnSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: DeleteCalendarOnSite(api.DeleteCalendarOnSiteRequest) returns (api.DeleteCalendarOnSiteResponse);
*/
deleteCalendarOnSite(input: DeleteCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<DeleteCalendarOnSiteRequest, DeleteCalendarOnSiteResponse> {
const method = this.methods[11], opt = this._transport.mergeOptions(options);
return stackIntercept<DeleteCalendarOnSiteRequest, DeleteCalendarOnSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ImportClassicHolidaysOnSite(api.ImportClassicHolidaysOnSiteRequest) returns (api.ImportClassicHolidaysOnSiteResponse);
*/
importClassicHolidaysOnSite(input: ImportClassicHolidaysOnSiteRequest, options?: RpcOptions): UnaryCall<ImportClassicHolidaysOnSiteRequest, ImportClassicHolidaysOnSiteResponse> {
const method = this.methods[12], opt = this._transport.mergeOptions(options);
return stackIntercept<ImportClassicHolidaysOnSiteRequest, ImportClassicHolidaysOnSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CloneCalendarOnSite(api.CloneCalendarOnSiteRequest) returns (api.CloneCalendarOnSiteResponse);
*/
cloneCalendarOnSite(input: CloneCalendarOnSiteRequest, options?: RpcOptions): UnaryCall<CloneCalendarOnSiteRequest, CloneCalendarOnSiteResponse> {
const method = this.methods[13], opt = this._transport.mergeOptions(options);
return stackIntercept<CloneCalendarOnSiteRequest, CloneCalendarOnSiteResponse>("unary", this._transport, method, opt, input);
}
}

2171
calendar.ts Normal file
View File

File diff suppressed because it is too large Load Diff

315
collabShared.ts
View File

@@ -10,6 +10,7 @@ import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import type { PartialMessage } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { QuantityByUnit } from "./slotbooking";
import { Struct } from "./google/protobuf/struct";
import { DateTime } from "./shared";
import { ClaimStatus } from "./shared";
@@ -146,6 +147,79 @@ export interface NotifChanges {
*/
details?: Struct;
}
//
// Appointment entity status structure
/**
* @generated from protobuf message api.AppointmentStatus
*/
export interface AppointmentStatus {
/**
* @generated from protobuf field: api.AppointmentStatusCode StatusCode = 1 [json_name = "StatusCode"];
*/
statusCode: AppointmentStatusCode;
/**
* @generated from protobuf field: string Date = 2 [json_name = "Date"];
*/
date: string;
/**
* Status effective date. Set by the event's RefDate that triggered the status change.
*
* @generated from protobuf field: api.DateTime ActualDate = 3 [json_name = "ActualDate"];
*/
actualDate?: DateTime;
}
//
// AppointmentStatusStruct statuses structure
/**
* @generated from protobuf message api.AppointmentStatusStruct
*/
export interface AppointmentStatusStruct {
/**
* Current status of the Appointment entity
*
* @generated from protobuf field: api.AppointmentStatus Current = 1 [json_name = "Current"];
*/
current?: AppointmentStatus;
/**
* List of all status history of the Appointment entity
*
* @generated from protobuf field: repeated api.AppointmentStatus History = 2 [json_name = "History"];
*/
history: AppointmentStatus[];
/**
* @generated from protobuf field: string CreationDate = 3 [json_name = "CreationDate"];
*/
creationDate: string;
/**
* @generated from protobuf field: uint32 Version = 4 [json_name = "Version"];
*/
version: number;
}
/**
* @generated from protobuf message api.Commission
*/
export interface Commission {
/**
* Identifier for the project associated with the order
*
* @generated from protobuf field: string ProjectID = 1 [json_name = "ProjectID"];
*/
projectID: string;
/**
* ID of the order, might be null for standalone
*
* @generated from protobuf field: string OrderID = 2 [json_name = "OrderID"];
*/
orderID: string;
/**
* Volumetry inside the truck, should have at least one item listed
*
* @generated from protobuf field: repeated api.QuantityByUnit Quantities = 3 [json_name = "Quantities"];
*/
quantities: QuantityByUnit[];
}
/**
* @generated from protobuf enum api.NotifTypeEnum
*/
@@ -191,6 +265,52 @@ export enum NotifTypeEnum {
*/
NOTIF_TYPE_COMPLETION = 9
}
// Appointment
/**
*
* All statuses for Appointment entity
*
* @generated from protobuf enum api.AppointmentStatusCode
*/
export enum AppointmentStatusCode {
/**
* @generated from protobuf enum value: APPOINTMENT_0000_STATUS_UNKNOWN = 0;
*/
APPOINTMENT_0000_STATUS_UNKNOWN = 0,
/**
* @generated from protobuf enum value: APPOINTMENT_0100_CARRIER_EXPECTED = 100;
*/
APPOINTMENT_0100_CARRIER_EXPECTED = 100,
/**
* @generated from protobuf enum value: APPOINTMENT_0200_CARRIER_ARRIVED = 200;
*/
APPOINTMENT_0200_CARRIER_ARRIVED = 200,
/**
* @generated from protobuf enum value: APPOINTMENT_0300_EXPEDITION_LOADING = 300;
*/
APPOINTMENT_0300_EXPEDITION_LOADING = 300,
/**
* @generated from protobuf enum value: APPOINTMENT_0400_EXPEDITION_LOADED = 400;
*/
APPOINTMENT_0400_EXPEDITION_LOADED = 400,
/**
* @generated from protobuf enum value: APPOINTMENT_0600_RECEPTION_UNLOADING = 600;
*/
APPOINTMENT_0600_RECEPTION_UNLOADING = 600,
/**
* @generated from protobuf enum value: APPOINTMENT_0700_RECEPTION_UNLOADED = 700;
*/
APPOINTMENT_0700_RECEPTION_UNLOADED = 700,
/**
* @generated from protobuf enum value: APPOINTMENT_0500_CARRIER_DEPARTED = 800;
*/
APPOINTMENT_0500_CARRIER_DEPARTED = 800,
/**
* @generated from protobuf enum value: APPOINTMENT_0800_CANCELLED = 1000;
*/
APPOINTMENT_0800_CANCELLED = 1000
}
// @generated message type with reflection information, may provide speed optimized methods
class ClaimStatusDef$Type extends MessageType<ClaimStatusDef> {
constructor() {
@@ -611,3 +731,198 @@ class NotifChanges$Type extends MessageType<NotifChanges> {
* @generated MessageType for protobuf message api.NotifChanges
*/
export const NotifChanges = new NotifChanges$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentStatus$Type extends MessageType<AppointmentStatus> {
constructor() {
super("api.AppointmentStatus", [
{ no: 1, name: "StatusCode", kind: "enum", jsonName: "StatusCode", T: () => ["api.AppointmentStatusCode", AppointmentStatusCode], options: { "api.indexationType": { Types: [{ Context: "*", Type: "generatedText" }] }, "api.kpiItems": {} } },
{ no: 2, name: "Date", kind: "scalar", jsonName: "Date", T: 9 /*ScalarType.STRING*/, options: { "api.indexationType": { Types: [{ Context: "*", Type: "date" }] }, "api.kpiItems": {}, "api.viewType": { Types: [{ Context: "*", Type: "date" }] } } },
{ no: 3, name: "ActualDate", kind: "message", jsonName: "ActualDate", T: () => DateTime, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Status effective date. Set by the event's RefDate that triggered the status change." } } }
]);
}
create(value?: PartialMessage<AppointmentStatus>): AppointmentStatus {
const message = globalThis.Object.create((this.messagePrototype!));
message.statusCode = 0;
message.date = "";
if (value !== undefined)
reflectionMergePartial<AppointmentStatus>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentStatus): AppointmentStatus {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.AppointmentStatusCode StatusCode = 1 [json_name = "StatusCode"];*/ 1:
message.statusCode = reader.int32();
break;
case /* string Date = 2 [json_name = "Date"];*/ 2:
message.date = reader.string();
break;
case /* api.DateTime ActualDate = 3 [json_name = "ActualDate"];*/ 3:
message.actualDate = DateTime.internalBinaryRead(reader, reader.uint32(), options, message.actualDate);
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: AppointmentStatus, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.AppointmentStatusCode StatusCode = 1 [json_name = "StatusCode"]; */
if (message.statusCode !== 0)
writer.tag(1, WireType.Varint).int32(message.statusCode);
/* string Date = 2 [json_name = "Date"]; */
if (message.date !== "")
writer.tag(2, WireType.LengthDelimited).string(message.date);
/* api.DateTime ActualDate = 3 [json_name = "ActualDate"]; */
if (message.actualDate)
DateTime.internalBinaryWrite(message.actualDate, 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.AppointmentStatus
*/
export const AppointmentStatus = new AppointmentStatus$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AppointmentStatusStruct$Type extends MessageType<AppointmentStatusStruct> {
constructor() {
super("api.AppointmentStatusStruct", [
{ no: 1, name: "Current", kind: "message", jsonName: "Current", T: () => AppointmentStatus, options: { "api.kpiExclude": { Items: [{ Context: "Stock", Group: "stock" }, { Context: "Stock", Group: "stock_extended" }, { Context: "Executionflow", Group: "executionflow" }, { Context: "Movement", Group: "movement" }, { Context: "Order", Group: "order" }, { Context: "Tracking", Group: "tracking" }] } } },
{ no: 2, name: "History", kind: "message", jsonName: "History", repeat: 1 /*RepeatType.PACKED*/, T: () => AppointmentStatus, options: { "api.aggKey": "Date", "api.kpiExclude": { Items: [{ Context: "Stock", Group: "stock" }, { Context: "Stock", Group: "stock_extended" }, { Context: "Executionflow", Group: "executionflow" }, { Context: "Movement", Group: "movement" }, { Context: "Order", Group: "order" }, { Context: "Actor", Group: "actor" }, { Context: "Tracking", Group: "tracking" }] } } },
{ no: 3, name: "CreationDate", kind: "scalar", jsonName: "CreationDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { dateIso8601: true } } } },
{ no: 4, name: "Version", kind: "scalar", jsonName: "Version", T: 13 /*ScalarType.UINT32*/ }
]);
}
create(value?: PartialMessage<AppointmentStatusStruct>): AppointmentStatusStruct {
const message = globalThis.Object.create((this.messagePrototype!));
message.history = [];
message.creationDate = "";
message.version = 0;
if (value !== undefined)
reflectionMergePartial<AppointmentStatusStruct>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentStatusStruct): AppointmentStatusStruct {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* api.AppointmentStatus Current = 1 [json_name = "Current"];*/ 1:
message.current = AppointmentStatus.internalBinaryRead(reader, reader.uint32(), options, message.current);
break;
case /* repeated api.AppointmentStatus History = 2 [json_name = "History"];*/ 2:
message.history.push(AppointmentStatus.internalBinaryRead(reader, reader.uint32(), options));
break;
case /* string CreationDate = 3 [json_name = "CreationDate"];*/ 3:
message.creationDate = reader.string();
break;
case /* uint32 Version = 4 [json_name = "Version"];*/ 4:
message.version = reader.uint32();
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: AppointmentStatusStruct, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* api.AppointmentStatus Current = 1 [json_name = "Current"]; */
if (message.current)
AppointmentStatus.internalBinaryWrite(message.current, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
/* repeated api.AppointmentStatus History = 2 [json_name = "History"]; */
for (let i = 0; i < message.history.length; i++)
AppointmentStatus.internalBinaryWrite(message.history[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
/* string CreationDate = 3 [json_name = "CreationDate"]; */
if (message.creationDate !== "")
writer.tag(3, WireType.LengthDelimited).string(message.creationDate);
/* uint32 Version = 4 [json_name = "Version"]; */
if (message.version !== 0)
writer.tag(4, WireType.Varint).uint32(message.version);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.AppointmentStatusStruct
*/
export const AppointmentStatusStruct = new AppointmentStatusStruct$Type();
// @generated message type with reflection information, may provide speed optimized methods
class Commission$Type extends MessageType<Commission> {
constructor() {
super("api.Commission", [
{ no: 1, name: "ProjectID", kind: "scalar", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
{ no: 2, name: "OrderID", kind: "scalar", jsonName: "OrderID", T: 9 /*ScalarType.STRING*/ },
{ no: 3, name: "Quantities", kind: "message", jsonName: "Quantities", repeat: 1 /*RepeatType.PACKED*/, T: () => QuantityByUnit, options: { "validate.rules": { repeated: { minItems: "1" } } } }
]);
}
create(value?: PartialMessage<Commission>): Commission {
const message = globalThis.Object.create((this.messagePrototype!));
message.projectID = "";
message.orderID = "";
message.quantities = [];
if (value !== undefined)
reflectionMergePartial<Commission>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Commission): Commission {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* string ProjectID = 1 [json_name = "ProjectID"];*/ 1:
message.projectID = reader.string();
break;
case /* string OrderID = 2 [json_name = "OrderID"];*/ 2:
message.orderID = reader.string();
break;
case /* repeated api.QuantityByUnit Quantities = 3 [json_name = "Quantities"];*/ 3:
message.quantities.push(QuantityByUnit.internalBinaryRead(reader, reader.uint32(), options));
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: Commission, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* string ProjectID = 1 [json_name = "ProjectID"]; */
if (message.projectID !== "")
writer.tag(1, WireType.LengthDelimited).string(message.projectID);
/* string OrderID = 2 [json_name = "OrderID"]; */
if (message.orderID !== "")
writer.tag(2, WireType.LengthDelimited).string(message.orderID);
/* repeated api.QuantityByUnit Quantities = 3 [json_name = "Quantities"]; */
for (let i = 0; i < message.quantities.length; i++)
QuantityByUnit.internalBinaryWrite(message.quantities[i], 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.Commission
*/
export const Commission = new Commission$Type();

10
index.ts
View File

@@ -16,6 +16,11 @@
export * from './adminConnection'
export * from './api.client'
export * from './api'
export * from './appointment'
export * from './appointmentInput.client'
export * from './appointmentInput'
export * from './appointmentQuery.client'
export * from './appointmentQuery'
export * from './attachmentType.client'
export * from './attachmentType'
export * from './attachmentV2.client'
@@ -23,6 +28,8 @@
export * from './base'
export * from './billing.client'
export * from './billing'
export * from './calendar.client'
export * from './calendar'
export * from './claim-type.client'
export * from './claim-type'
export * from './claim'
@@ -137,6 +144,9 @@
export * from './rules.client'
export * from './rules'
export * from './shared'
export * from './site.client'
export * from './site'
export * from './slotbooking'
export * from './stock'
export * from './stockAction'
export * from './stockInput.client'

2
package.json
View File

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

80
repositoryShared.ts
View File

@@ -612,6 +612,23 @@ export interface LVDetailedQuantity {
*/
quantity: number;
}
/**
* @generated from protobuf message api.SiteAlias
*/
export interface SiteAlias {
/**
* @generated from protobuf field: string OrganisationID = 1 [json_name = "OrganisationID"];
*/
organisationID: string;
/**
* @generated from protobuf field: string SiteID = 2 [json_name = "SiteID"];
*/
siteID: string;
/**
* @generated from protobuf field: string SiteName = 3 [json_name = "SiteName"];
*/
siteName: string;
}
//
// This files contains domain objects
@@ -2477,3 +2494,66 @@ class LVDetailedQuantity$Type extends MessageType<LVDetailedQuantity> {
* @generated MessageType for protobuf message api.LVDetailedQuantity
*/
export const LVDetailedQuantity = new LVDetailedQuantity$Type();
// @generated message type with reflection information, may provide speed optimized methods
class SiteAlias$Type extends MessageType<SiteAlias> {
constructor() {
super("api.SiteAlias", [
{ no: 1, name: "OrganisationID", kind: "scalar", jsonName: "OrganisationID", T: 9 /*ScalarType.STRING*/ },
{ no: 2, name: "SiteID", kind: "scalar", jsonName: "SiteID", T: 9 /*ScalarType.STRING*/ },
{ no: 3, name: "SiteName", kind: "scalar", jsonName: "SiteName", T: 9 /*ScalarType.STRING*/ }
]);
}
create(value?: PartialMessage<SiteAlias>): SiteAlias {
const message = globalThis.Object.create((this.messagePrototype!));
message.organisationID = "";
message.siteID = "";
message.siteName = "";
if (value !== undefined)
reflectionMergePartial<SiteAlias>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SiteAlias): SiteAlias {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* string OrganisationID = 1 [json_name = "OrganisationID"];*/ 1:
message.organisationID = reader.string();
break;
case /* string SiteID = 2 [json_name = "SiteID"];*/ 2:
message.siteID = reader.string();
break;
case /* string SiteName = 3 [json_name = "SiteName"];*/ 3:
message.siteName = reader.string();
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: SiteAlias, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* string OrganisationID = 1 [json_name = "OrganisationID"]; */
if (message.organisationID !== "")
writer.tag(1, WireType.LengthDelimited).string(message.organisationID);
/* string SiteID = 2 [json_name = "SiteID"]; */
if (message.siteID !== "")
writer.tag(2, WireType.LengthDelimited).string(message.siteID);
/* string SiteName = 3 [json_name = "SiteName"]; */
if (message.siteName !== "")
writer.tag(3, WireType.LengthDelimited).string(message.siteName);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.SiteAlias
*/
export const SiteAlias = new SiteAlias$Type();

285
shared.ts
View File

@@ -52,6 +52,29 @@ export interface RequestProjectHeader {
*/
technicalID: string;
}
/**
* Header for all requests on site resources
*
* @generated from protobuf message api.RequestSiteHeader
*/
export interface RequestSiteHeader {
/**
* Identifier of the site
*
* @generated from protobuf field: string SiteID = 1 [json_name = "SiteID"];
*/
siteID: string;
/**
* DateTime ActualDate = 2 ;
*
* @generated from protobuf field: string CorrelationID = 3 [json_name = "CorrelationID"];
*/
correlationID: string;
/**
* @generated from protobuf field: string TechnicalID = 4 [json_name = "TechnicalID"];
*/
technicalID: string;
}
/**
* Header for all requests on organisation resources
*
@@ -158,7 +181,7 @@ export interface RequestAttachmentTypeHeader {
technicalID: string;
}
/**
* Header for all response messages
* Header for all project response messages
*
* @generated from protobuf message api.ResponseHeader
*/
@@ -178,6 +201,27 @@ export interface ResponseHeader {
*/
technicalID: string;
}
/**
* Header for all site response messages
*
* @generated from protobuf message api.ResponseSiteHeader
*/
export interface ResponseSiteHeader {
/**
* Identifier of the site
*
* @generated from protobuf field: string SiteID = 1 [json_name = "SiteID"];
*/
siteID: string;
/**
* @generated from protobuf field: string CorrelationID = 2 [json_name = "CorrelationID"];
*/
correlationID: string;
/**
* @generated from protobuf field: string TechnicalID = 3 [json_name = "TechnicalID"];
*/
technicalID: string;
}
/**
* Header for all response messages
*
@@ -324,6 +368,8 @@ export interface EventHeader {
// DateTime ActualDate = 6; // TODO : add validation rule to make it required : [(validate.rules).message.required = true]
/**
* TODO How to manage Site here ? just rename this attribute in Parent ??
*
* @generated from protobuf field: string Project = 3 [json_name = "Project"];
*/
project: string;
@@ -1750,6 +1796,19 @@ export interface MatchFieldElementResult {
[key: string]: string;
};
}
/**
* @generated from protobuf message api.LabelByLanguage
*/
export interface LabelByLanguage {
/**
* @generated from protobuf field: string Value = 1 [json_name = "Value"];
*/
value: string;
/**
* @generated from protobuf field: string LanguageCodeISO6391 = 2 [json_name = "LanguageCodeISO6391"];
*/
languageCodeISO6391: string;
}
/**
* List all data set in the model
*
@@ -1801,6 +1860,43 @@ export enum ModelDataSetEnum {
*/
CLAIM = 10
}
/**
* @generated from protobuf enum api.WeekDay
*/
export enum WeekDay {
/**
* @generated from protobuf enum value: WEEKDAY_UNDEFINED = 0;
*/
WEEKDAY_UNDEFINED = 0,
/**
* @generated from protobuf enum value: WEEKDAY_MONDAY = 1;
*/
WEEKDAY_MONDAY = 1,
/**
* @generated from protobuf enum value: WEEKDAY_TUESDAY = 2;
*/
WEEKDAY_TUESDAY = 2,
/**
* @generated from protobuf enum value: WEEKDAY_WEDNESDAY = 3;
*/
WEEKDAY_WEDNESDAY = 3,
/**
* @generated from protobuf enum value: WEEKDAY_THURSDAY = 4;
*/
WEEKDAY_THURSDAY = 4,
/**
* @generated from protobuf enum value: WEEKDAY_FRIDAY = 5;
*/
WEEKDAY_FRIDAY = 5,
/**
* @generated from protobuf enum value: WEEKDAY_SATURDAY = 6;
*/
WEEKDAY_SATURDAY = 6,
/**
* @generated from protobuf enum value: WEEKDAY_SUNDAY = 7;
*/
WEEKDAY_SUNDAY = 7
}
/**
* @generated from protobuf enum api.SeverityLevel
*/
@@ -2381,7 +2477,11 @@ export enum ResourceType {
/**
* @generated from protobuf enum value: RESOURCE_TYPE_CLAIMTYPE = 70;
*/
CLAIMTYPE = 70
CLAIMTYPE = 70,
/**
* @generated from protobuf enum value: RESOURCE_TYPE_SITE = 80;
*/
SITE = 80
}
// @generated message type with reflection information, may provide speed optimized methods
class RequestHeader$Type extends MessageType<RequestHeader> {
@@ -2494,6 +2594,69 @@ class RequestProjectHeader$Type extends MessageType<RequestProjectHeader> {
*/
export const RequestProjectHeader = new RequestProjectHeader$Type();
// @generated message type with reflection information, may provide speed optimized methods
class RequestSiteHeader$Type extends MessageType<RequestSiteHeader> {
constructor() {
super("api.RequestSiteHeader", [
{ no: 1, name: "SiteID", kind: "scalar", jsonName: "SiteID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1", notContains: " " } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Identifier of the site", example: "\"Your_Site_ID\"" } } },
{ no: 3, name: "CorrelationID", kind: "scalar", jsonName: "CorrelationID", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "This ID is sent back into the response header in order to be able to correlate request and response", example: "\"CorrID_A\"" } } },
{ no: 4, name: "TechnicalID", kind: "scalar", jsonName: "TechnicalID", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "This ID is sent back into the response header in order to be able to correlate request and response", example: "\"TechID_A\"" } } }
], { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_schema": { jsonSchema: { required: ["SiteID"] } } });
}
create(value?: PartialMessage<RequestSiteHeader>): RequestSiteHeader {
const message = globalThis.Object.create((this.messagePrototype!));
message.siteID = "";
message.correlationID = "";
message.technicalID = "";
if (value !== undefined)
reflectionMergePartial<RequestSiteHeader>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RequestSiteHeader): RequestSiteHeader {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* string SiteID = 1 [json_name = "SiteID"];*/ 1:
message.siteID = reader.string();
break;
case /* string CorrelationID = 3 [json_name = "CorrelationID"];*/ 3:
message.correlationID = reader.string();
break;
case /* string TechnicalID = 4 [json_name = "TechnicalID"];*/ 4:
message.technicalID = reader.string();
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: RequestSiteHeader, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* string SiteID = 1 [json_name = "SiteID"]; */
if (message.siteID !== "")
writer.tag(1, WireType.LengthDelimited).string(message.siteID);
/* string CorrelationID = 3 [json_name = "CorrelationID"]; */
if (message.correlationID !== "")
writer.tag(3, WireType.LengthDelimited).string(message.correlationID);
/* string TechnicalID = 4 [json_name = "TechnicalID"]; */
if (message.technicalID !== "")
writer.tag(4, WireType.LengthDelimited).string(message.technicalID);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.RequestSiteHeader
*/
export const RequestSiteHeader = new RequestSiteHeader$Type();
// @generated message type with reflection information, may provide speed optimized methods
class RequestOrganisationHeader$Type extends MessageType<RequestOrganisationHeader> {
constructor() {
super("api.RequestOrganisationHeader", [
@@ -2872,6 +3035,69 @@ class ResponseHeader$Type extends MessageType<ResponseHeader> {
*/
export const ResponseHeader = new ResponseHeader$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ResponseSiteHeader$Type extends MessageType<ResponseSiteHeader> {
constructor() {
super("api.ResponseSiteHeader", [
{ no: 1, name: "SiteID", kind: "scalar", jsonName: "SiteID", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Identifier of the site" } } },
{ no: 2, name: "CorrelationID", kind: "scalar", jsonName: "CorrelationID", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "This ID is filled using the request CorrelationID if provided in order to be able to correlate request and response", example: "\"CorrID_A\"" } } },
{ no: 3, name: "TechnicalID", kind: "scalar", jsonName: "TechnicalID", T: 9 /*ScalarType.STRING*/, options: { "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "This ID is filled using the request TechnicalID if provided in order to be able to correlate request and response", example: "\"TechID_A\"" } } }
]);
}
create(value?: PartialMessage<ResponseSiteHeader>): ResponseSiteHeader {
const message = globalThis.Object.create((this.messagePrototype!));
message.siteID = "";
message.correlationID = "";
message.technicalID = "";
if (value !== undefined)
reflectionMergePartial<ResponseSiteHeader>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ResponseSiteHeader): ResponseSiteHeader {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* string SiteID = 1 [json_name = "SiteID"];*/ 1:
message.siteID = reader.string();
break;
case /* string CorrelationID = 2 [json_name = "CorrelationID"];*/ 2:
message.correlationID = reader.string();
break;
case /* string TechnicalID = 3 [json_name = "TechnicalID"];*/ 3:
message.technicalID = reader.string();
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: ResponseSiteHeader, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* string SiteID = 1 [json_name = "SiteID"]; */
if (message.siteID !== "")
writer.tag(1, WireType.LengthDelimited).string(message.siteID);
/* string CorrelationID = 2 [json_name = "CorrelationID"]; */
if (message.correlationID !== "")
writer.tag(2, WireType.LengthDelimited).string(message.correlationID);
/* string TechnicalID = 3 [json_name = "TechnicalID"]; */
if (message.technicalID !== "")
writer.tag(3, WireType.LengthDelimited).string(message.technicalID);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.ResponseSiteHeader
*/
export const ResponseSiteHeader = new ResponseSiteHeader$Type();
// @generated message type with reflection information, may provide speed optimized methods
class AttachmentTypeResponseHeader$Type extends MessageType<AttachmentTypeResponseHeader> {
constructor() {
super("api.AttachmentTypeResponseHeader", [
@@ -7387,3 +7613,58 @@ class MatchFieldElementResult$Type extends MessageType<MatchFieldElementResult>
* @generated MessageType for protobuf message api.MatchFieldElementResult
*/
export const MatchFieldElementResult = new MatchFieldElementResult$Type();
// @generated message type with reflection information, may provide speed optimized methods
class LabelByLanguage$Type extends MessageType<LabelByLanguage> {
constructor() {
super("api.LabelByLanguage", [
{ no: 1, name: "Value", kind: "scalar", jsonName: "Value", T: 9 /*ScalarType.STRING*/ },
{ no: 2, name: "LanguageCodeISO6391", kind: "scalar", jsonName: "LanguageCodeISO6391", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "2", maxLen: "3", languageIso639: true } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "<a href='https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes'>ISO 639 code</a> message language", example: "\"en\"" } } }
]);
}
create(value?: PartialMessage<LabelByLanguage>): LabelByLanguage {
const message = globalThis.Object.create((this.messagePrototype!));
message.value = "";
message.languageCodeISO6391 = "";
if (value !== undefined)
reflectionMergePartial<LabelByLanguage>(this, message, value);
return message;
}
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: LabelByLanguage): LabelByLanguage {
let message = target ?? this.create(), end = reader.pos + length;
while (reader.pos < end) {
let [fieldNo, wireType] = reader.tag();
switch (fieldNo) {
case /* string Value = 1 [json_name = "Value"];*/ 1:
message.value = reader.string();
break;
case /* string LanguageCodeISO6391 = 2 [json_name = "LanguageCodeISO6391"];*/ 2:
message.languageCodeISO6391 = reader.string();
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: LabelByLanguage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
/* string Value = 1 [json_name = "Value"]; */
if (message.value !== "")
writer.tag(1, WireType.LengthDelimited).string(message.value);
/* string LanguageCodeISO6391 = 2 [json_name = "LanguageCodeISO6391"]; */
if (message.languageCodeISO6391 !== "")
writer.tag(2, WireType.LengthDelimited).string(message.languageCodeISO6391);
let u = options.writeUnknownFields;
if (u !== false)
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
return writer;
}
}
/**
* @generated MessageType for protobuf message api.LabelByLanguage
*/
export const LabelByLanguage = new LabelByLanguage$Type();

141
site.client.ts Normal file
View File

@@ -0,0 +1,141 @@
// @generated by protobuf-ts 2.9.6
// @generated from protobuf file "site.proto" (package "api", syntax proto3)
// tslint:disable
import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
import { SiteService } from "./site";
import type { CancelAppointmentResponse } from "./site";
import type { CancelAppointmentRequest } from "./site";
import type { BookAppointmentResponse } from "./site";
import type { BookAppointmentRequest } from "./site";
import type { ListUserSitesResponse } from "./site";
import type { ListUserSitesRequest } from "./site";
import type { GetAvailableSlotsResponse } from "./site";
import type { GetAvailableSlotsRequest } from "./site";
import type { DeleteSiteResponse } from "./site";
import type { DeleteSiteRequest } from "./site";
import type { UpdateSiteResponse } from "./site";
import type { UpdateSiteRequest } from "./site";
import type { ListSiteResponse } from "./site";
import type { ListSiteRequest } from "./site";
import type { GetSiteResponse } from "./site";
import type { GetSiteRequest } from "./site";
import { stackIntercept } from "@protobuf-ts/runtime-rpc";
import type { CreateSiteResponse } from "./site";
import type { CreateSiteRequest } from "./site";
import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
/**
* @generated from protobuf service api.SiteService
*/
export interface ISiteServiceClient {
/**
* @generated from protobuf rpc: Create(api.CreateSiteRequest) returns (api.CreateSiteResponse);
*/
create(input: CreateSiteRequest, options?: RpcOptions): UnaryCall<CreateSiteRequest, CreateSiteResponse>;
/**
* @generated from protobuf rpc: Get(api.GetSiteRequest) returns (api.GetSiteResponse);
*/
get(input: GetSiteRequest, options?: RpcOptions): UnaryCall<GetSiteRequest, GetSiteResponse>;
/**
* @generated from protobuf rpc: List(api.ListSiteRequest) returns (api.ListSiteResponse);
*/
list(input: ListSiteRequest, options?: RpcOptions): UnaryCall<ListSiteRequest, ListSiteResponse>;
/**
* @generated from protobuf rpc: Update(api.UpdateSiteRequest) returns (api.UpdateSiteResponse);
*/
update(input: UpdateSiteRequest, options?: RpcOptions): UnaryCall<UpdateSiteRequest, UpdateSiteResponse>;
/**
* @generated from protobuf rpc: Delete(api.DeleteSiteRequest) returns (api.DeleteSiteResponse);
*/
delete(input: DeleteSiteRequest, options?: RpcOptions): UnaryCall<DeleteSiteRequest, DeleteSiteResponse>;
/**
* @generated from protobuf rpc: GetAvailableSlots(api.GetAvailableSlotsRequest) returns (api.GetAvailableSlotsResponse);
*/
getAvailableSlots(input: GetAvailableSlotsRequest, options?: RpcOptions): UnaryCall<GetAvailableSlotsRequest, GetAvailableSlotsResponse>;
/**
* @generated from protobuf rpc: ListUserSites(api.ListUserSitesRequest) returns (api.ListUserSitesResponse);
*/
listUserSites(input: ListUserSitesRequest, options?: RpcOptions): UnaryCall<ListUserSitesRequest, ListUserSitesResponse>;
/**
* @generated from protobuf rpc: BookAppointment(api.BookAppointmentRequest) returns (api.BookAppointmentResponse);
*/
bookAppointment(input: BookAppointmentRequest, options?: RpcOptions): UnaryCall<BookAppointmentRequest, BookAppointmentResponse>;
/**
* @generated from protobuf rpc: CancelAppointment(api.CancelAppointmentRequest) returns (api.CancelAppointmentResponse);
*/
cancelAppointment(input: CancelAppointmentRequest, options?: RpcOptions): UnaryCall<CancelAppointmentRequest, CancelAppointmentResponse>;
}
/**
* @generated from protobuf service api.SiteService
*/
export class SiteServiceClient implements ISiteServiceClient, ServiceInfo {
typeName = SiteService.typeName;
methods = SiteService.methods;
options = SiteService.options;
constructor(private readonly _transport: RpcTransport) {
}
/**
* @generated from protobuf rpc: Create(api.CreateSiteRequest) returns (api.CreateSiteResponse);
*/
create(input: CreateSiteRequest, options?: RpcOptions): UnaryCall<CreateSiteRequest, CreateSiteResponse> {
const method = this.methods[0], opt = this._transport.mergeOptions(options);
return stackIntercept<CreateSiteRequest, CreateSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Get(api.GetSiteRequest) returns (api.GetSiteResponse);
*/
get(input: GetSiteRequest, options?: RpcOptions): UnaryCall<GetSiteRequest, GetSiteResponse> {
const method = this.methods[1], opt = this._transport.mergeOptions(options);
return stackIntercept<GetSiteRequest, GetSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: List(api.ListSiteRequest) returns (api.ListSiteResponse);
*/
list(input: ListSiteRequest, options?: RpcOptions): UnaryCall<ListSiteRequest, ListSiteResponse> {
const method = this.methods[2], opt = this._transport.mergeOptions(options);
return stackIntercept<ListSiteRequest, ListSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Update(api.UpdateSiteRequest) returns (api.UpdateSiteResponse);
*/
update(input: UpdateSiteRequest, options?: RpcOptions): UnaryCall<UpdateSiteRequest, UpdateSiteResponse> {
const method = this.methods[3], opt = this._transport.mergeOptions(options);
return stackIntercept<UpdateSiteRequest, UpdateSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: Delete(api.DeleteSiteRequest) returns (api.DeleteSiteResponse);
*/
delete(input: DeleteSiteRequest, options?: RpcOptions): UnaryCall<DeleteSiteRequest, DeleteSiteResponse> {
const method = this.methods[4], opt = this._transport.mergeOptions(options);
return stackIntercept<DeleteSiteRequest, DeleteSiteResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: GetAvailableSlots(api.GetAvailableSlotsRequest) returns (api.GetAvailableSlotsResponse);
*/
getAvailableSlots(input: GetAvailableSlotsRequest, options?: RpcOptions): UnaryCall<GetAvailableSlotsRequest, GetAvailableSlotsResponse> {
const method = this.methods[5], opt = this._transport.mergeOptions(options);
return stackIntercept<GetAvailableSlotsRequest, GetAvailableSlotsResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: ListUserSites(api.ListUserSitesRequest) returns (api.ListUserSitesResponse);
*/
listUserSites(input: ListUserSitesRequest, options?: RpcOptions): UnaryCall<ListUserSitesRequest, ListUserSitesResponse> {
const method = this.methods[6], opt = this._transport.mergeOptions(options);
return stackIntercept<ListUserSitesRequest, ListUserSitesResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: BookAppointment(api.BookAppointmentRequest) returns (api.BookAppointmentResponse);
*/
bookAppointment(input: BookAppointmentRequest, options?: RpcOptions): UnaryCall<BookAppointmentRequest, BookAppointmentResponse> {
const method = this.methods[7], opt = this._transport.mergeOptions(options);
return stackIntercept<BookAppointmentRequest, BookAppointmentResponse>("unary", this._transport, method, opt, input);
}
/**
* @generated from protobuf rpc: CancelAppointment(api.CancelAppointmentRequest) returns (api.CancelAppointmentResponse);
*/
cancelAppointment(input: CancelAppointmentRequest, options?: RpcOptions): UnaryCall<CancelAppointmentRequest, CancelAppointmentResponse> {
const method = this.methods[8], opt = this._transport.mergeOptions(options);
return stackIntercept<CancelAppointmentRequest, CancelAppointmentResponse>("unary", this._transport, method, opt, input);
}
}

1900
site.ts Normal file
View File

File diff suppressed because it is too large Load Diff

2287
slotbooking.ts Normal file
View File

File diff suppressed because it is too large Load Diff