You've already forked npm-core-sdk
2593 lines
124 KiB
TypeScript
2593 lines
124 KiB
TypeScript
// @generated by protobuf-ts 2.11.1 with parameter use_proto_field_name,keep_enum_prefix
|
|
// @generated from protobuf file "slotbooking.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 { Period } from "./shared";
|
|
import { TimeRange } from "./shared";
|
|
import { WeekDay } from "./shared";
|
|
import { LabelByLanguage } from "./shared";
|
|
/**
|
|
* avant la def de la sous structure
|
|
*
|
|
* @generated from protobuf message api.Unit
|
|
*/
|
|
export interface Unit {
|
|
/**
|
|
* @generated from protobuf field: string UnitID = 1
|
|
*/
|
|
UnitID: string;
|
|
/**
|
|
* @generated from protobuf field: repeated api.LabelByLanguage Labels = 2
|
|
*/
|
|
Labels: LabelByLanguage[]; // @option language
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.QuantityByUnit
|
|
*/
|
|
export interface QuantityByUnit {
|
|
/**
|
|
* referring to the Unit ID defined by the Site
|
|
*
|
|
* @generated from protobuf field: string UnitID = 1
|
|
*/
|
|
UnitID: string;
|
|
/**
|
|
* Number of the specified unit
|
|
*
|
|
* @generated from protobuf field: double Value = 2
|
|
*/
|
|
Value: number;
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.Slot
|
|
*/
|
|
export interface Slot {
|
|
/**
|
|
* @generated from protobuf field: string StartDateTime = 1
|
|
*/
|
|
StartDateTime: string; // Slot start date time, format yyyy-mm-jjThh:mm:ss (iso8601 without timezone).
|
|
// because the time zone is defined by the site on which the slot is booked
|
|
|
|
/**
|
|
* Slot duration in seconds.
|
|
*
|
|
* @generated from protobuf field: uint64 DurationInSeconds = 3
|
|
*/
|
|
DurationInSeconds: bigint;
|
|
/**
|
|
* @generated from protobuf field: string EndDateTime = 4
|
|
*/
|
|
EndDateTime: string;
|
|
}
|
|
/**
|
|
* Segmentation
|
|
*
|
|
* @generated from protobuf message api.Segmentation
|
|
*/
|
|
export interface Segmentation {
|
|
/**
|
|
* Identifier of the Segmentation.
|
|
*
|
|
* @generated from protobuf field: string SegmentationID = 1
|
|
*/
|
|
SegmentationID: string;
|
|
/**
|
|
* Translated labels of the Segmentation.
|
|
*
|
|
* @generated from protobuf field: repeated api.LabelByLanguage SegmentationLabels = 2
|
|
*/
|
|
SegmentationLabels: LabelByLanguage[]; // @option language
|
|
/**
|
|
* Possible values of the Segmentation.
|
|
*
|
|
* @generated from protobuf field: repeated api.SegmentationValue Values = 3
|
|
*/
|
|
Values: SegmentationValue[];
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.SegmentationValue
|
|
*/
|
|
export interface SegmentationValue {
|
|
/**
|
|
* Identifier of the Segmentation value.
|
|
*
|
|
* @generated from protobuf field: string ID = 1
|
|
*/
|
|
ID: string;
|
|
/**
|
|
* Translated labels of the Segmentation value.
|
|
*
|
|
* @generated from protobuf field: repeated api.LabelByLanguage Labels = 2
|
|
*/
|
|
Labels: LabelByLanguage[]; // @option language
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.Instruction
|
|
*/
|
|
export interface Instruction {
|
|
/**
|
|
* @generated from protobuf field: repeated api.LabelByLanguage InstructionByLanguage = 15
|
|
*/
|
|
InstructionByLanguage: LabelByLanguage[]; // @option language
|
|
/**
|
|
* @generated from protobuf field: bool AckRequired = 2
|
|
*/
|
|
AckRequired: boolean;
|
|
}
|
|
/**
|
|
* OpeningRule
|
|
*
|
|
* @generated from protobuf message api.OpeningRule
|
|
*/
|
|
export interface OpeningRule {
|
|
/**
|
|
* TODO Add time
|
|
*
|
|
* @generated from protobuf field: string StartDate = 1
|
|
*/
|
|
StartDate: string; // Start date of the opening rule validity, format yyyy-mm-jj .
|
|
/**
|
|
* @generated from protobuf field: string EndDate = 2
|
|
*/
|
|
EndDate: string; // End date of the opening rule validity, format yyyy-mm-jj .
|
|
/**
|
|
* @generated from protobuf field: repeated api.OpeningDay OpeningDays = 3
|
|
*/
|
|
OpeningDays: OpeningDay[]; // Definition of the opening rules by week day.
|
|
/**
|
|
* @generated from protobuf field: string CalendarID = 4
|
|
*/
|
|
CalendarID: string; // The identifier of the calendar to be used within this period of time.
|
|
/**
|
|
* @generated from protobuf field: string Label = 5
|
|
*/
|
|
Label: string; // Label of the Rule.
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.OpeningDay
|
|
*/
|
|
export interface OpeningDay {
|
|
/**
|
|
* @generated from protobuf field: api.WeekDay WeekDay = 1
|
|
*/
|
|
WeekDay: WeekDay; // Day of the week.
|
|
/**
|
|
* @generated from protobuf field: repeated api.OpeningDayDefinition Definitions = 2
|
|
*/
|
|
Definitions: OpeningDayDefinition[]; // Opening hours definition according to filters.
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.OpeningDayDefinition
|
|
*/
|
|
export interface OpeningDayDefinition {
|
|
/**
|
|
* @generated from protobuf field: repeated api.TimeRange TimeRanges = 2
|
|
*/
|
|
TimeRanges: TimeRange[]; // List of opening hours.
|
|
/**
|
|
* @generated from protobuf field: api.RuleFilter Filter = 3
|
|
*/
|
|
Filter?: RuleFilter; // Validity filters for this opening rule definition.
|
|
/**
|
|
* @generated from protobuf field: int32 OrderAppliance = 4
|
|
*/
|
|
OrderAppliance: number; // Order in which the Rule will be applied.
|
|
/**
|
|
* @generated from protobuf field: bool ApplyCalendarTimetable = 5
|
|
*/
|
|
ApplyCalendarTimetable: boolean; // boolean to set at true when we want to apply the timetable of the calendar to this specific OpeningDayDefinition, when the calendar in use will be updated, the timetable will automatically be updated
|
|
}
|
|
/**
|
|
* CapacityRule
|
|
*
|
|
* @generated from protobuf message api.CapacityRule
|
|
*/
|
|
export interface CapacityRule {
|
|
/**
|
|
* @generated from protobuf field: string StartDate = 1
|
|
*/
|
|
StartDate: string; // Start date of the capacity rule validity, format yyyy-mm-jj.
|
|
/**
|
|
* @generated from protobuf field: string EndDate = 2
|
|
*/
|
|
EndDate: string; // End date of the capacity rule validity, format yyyy-mm-jj.
|
|
/**
|
|
* @generated from protobuf field: string Label = 5
|
|
*/
|
|
Label: string; // Label of the Rule
|
|
/**
|
|
* @generated from protobuf field: repeated api.WeekDay Days = 3
|
|
*/
|
|
Days: WeekDay[]; // List of the days on which this rule is applied.
|
|
/**
|
|
* @generated from protobuf field: repeated api.CapacityDefinition Capacities = 4
|
|
*/
|
|
Capacities: CapacityDefinition[]; // Definition of the capacity rules.
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.CapacityDefinition
|
|
*/
|
|
export interface CapacityDefinition {
|
|
/**
|
|
* @generated from protobuf field: api.RuleFilter Filter = 1
|
|
*/
|
|
Filter?: RuleFilter; // Validity filters for this capacity rule definition.
|
|
/**
|
|
* @generated from protobuf field: api.CapacityRuleScope Scope = 2
|
|
*/
|
|
Scope: CapacityRuleScope; // Scope of the rule, simultaneous or daily.
|
|
/**
|
|
* @generated from protobuf field: int64 MaximalCapacity = 3
|
|
*/
|
|
MaximalCapacity: bigint; // The capacity constraint to apply.
|
|
/**
|
|
* @generated from protobuf field: string UnitID = 4
|
|
*/
|
|
UnitID: string; // Site unit identifier of the capacity.
|
|
}
|
|
/**
|
|
* DurationRule
|
|
*
|
|
* @generated from protobuf message api.DurationRule
|
|
*/
|
|
export interface DurationRule {
|
|
/**
|
|
* Validity filters for this duration rule definition.
|
|
*
|
|
* @generated from protobuf field: api.RuleFilter Filter = 1
|
|
*/
|
|
Filter?: RuleFilter;
|
|
/**
|
|
* @generated from protobuf field: uint64 BaseDurationInSeconds = 2
|
|
*/
|
|
BaseDurationInSeconds: bigint; // Base duration in seconds
|
|
/**
|
|
* Variable duration definition by site unit.
|
|
*
|
|
* @generated from protobuf field: repeated api.VariableDuration VariableDurations = 3
|
|
*/
|
|
VariableDurations: VariableDuration[];
|
|
/**
|
|
* @generated from protobuf field: int32 OrderAppliance = 4
|
|
*/
|
|
OrderAppliance: number; // Order in which the Rule will be applied
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.VariableDuration
|
|
*/
|
|
export interface VariableDuration {
|
|
/**
|
|
* @generated from protobuf field: string UnitID = 1
|
|
*/
|
|
UnitID: string; // Site unit identifier
|
|
/**
|
|
* @generated from protobuf field: uint64 DurationInSeconds = 2
|
|
*/
|
|
DurationInSeconds: bigint; // Duration in seconds
|
|
}
|
|
/**
|
|
* Conditions on ProjectID, AppointmentType or/and Segmentation keys
|
|
*
|
|
* @generated from protobuf message api.RuleFilter
|
|
*/
|
|
export interface RuleFilter {
|
|
/**
|
|
* Filter on appointment type (loading or unloading).
|
|
*
|
|
* @generated from protobuf field: api.AppointmentType Type = 1
|
|
*/
|
|
Type: AppointmentType;
|
|
/**
|
|
* Filter on project identifier.
|
|
*
|
|
* @generated from protobuf field: repeated string ProjectID = 2
|
|
*/
|
|
ProjectID: string[];
|
|
/**
|
|
* Filter on site Segmentation keys.
|
|
*
|
|
* @generated from protobuf field: repeated api.SegmentationFilter SegmentationKeys = 3
|
|
*/
|
|
SegmentationKeys: SegmentationFilter[];
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.SegmentationFilter
|
|
*/
|
|
export interface SegmentationFilter {
|
|
/**
|
|
* Identifier of the Segmentation key.
|
|
*
|
|
* @generated from protobuf field: string SegmentationID = 1
|
|
*/
|
|
SegmentationID: string;
|
|
/**
|
|
* Identifiers of the Segmentation key values.
|
|
*
|
|
* @generated from protobuf field: repeated string SegmentationValueIDs = 2
|
|
*/
|
|
SegmentationValueIDs: string[];
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.SegmentationSelection
|
|
*/
|
|
export interface SegmentationSelection {
|
|
/**
|
|
* Identifier of the Segmentation key.
|
|
*
|
|
* @generated from protobuf field: string SegmentationID = 1
|
|
*/
|
|
SegmentationID: string;
|
|
/**
|
|
* Identifiers of the Segmentation key values.
|
|
*
|
|
* @generated from protobuf field: string SegmentationValueID = 2
|
|
*/
|
|
SegmentationValueID: string;
|
|
}
|
|
// enum CarrierInformationType {
|
|
// CARRIER_INFORMATION_TYPE_UNKNOWN = 0;
|
|
// CARRIER_INFORMATION_TYPE_DOCUMENT = 1;
|
|
// CARRIER_INFORMATION_TYPE_METADATA = 2;
|
|
// }
|
|
|
|
// // CarrierInformation
|
|
// // The five following messages are pretty similar, for each added object, they can add a translated version
|
|
// message CarrierInformation {
|
|
// string CarrierInformationID = 1;
|
|
// repeated LabelByLanguage Labels = 2
|
|
// [
|
|
// (language) = true,
|
|
// (aggKey) = "LanguageCodeISO6391"
|
|
// ]; // @option language
|
|
// CarrierInformationType Type = 3;
|
|
// bool IsMandatory = 4;
|
|
// bool FormatCheck = 5;
|
|
// }
|
|
|
|
// message CarrierInformationWithValue{
|
|
// CarrierInformation CarrierInformation = 1;
|
|
// string Value = 2;
|
|
// }
|
|
|
|
/**
|
|
* Document
|
|
* We anticipate that they want to put several but if they only have one with all the language, it should still work
|
|
*
|
|
* @generated from protobuf message api.Document
|
|
*/
|
|
export interface Document {
|
|
/**
|
|
* @generated from protobuf field: string DocID = 1
|
|
*/
|
|
DocID: string;
|
|
/**
|
|
* @generated from protobuf field: repeated api.DocumentByLanguage DocsByLang = 2
|
|
*/
|
|
DocsByLang: DocumentByLanguage[]; // @option language
|
|
/**
|
|
* @generated from protobuf field: bool AckRequired = 3
|
|
*/
|
|
AckRequired: boolean;
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.DocumentByLanguage
|
|
*/
|
|
export interface DocumentByLanguage {
|
|
/**
|
|
* @generated from protobuf field: string Name = 1
|
|
*/
|
|
Name: string;
|
|
/**
|
|
* bytes Doc = 2;
|
|
*
|
|
* @generated from protobuf field: string URI = 4
|
|
*/
|
|
URI: string;
|
|
/**
|
|
* @generated from protobuf field: string LanguageCodeISO6391 = 3
|
|
*/
|
|
LanguageCodeISO6391: string;
|
|
/**
|
|
* @generated from protobuf field: string FileName = 5
|
|
*/
|
|
FileName: string;
|
|
/**
|
|
* @generated from protobuf field: string LongURI = 6
|
|
*/
|
|
LongURI: string;
|
|
}
|
|
/**
|
|
* Authorisation
|
|
*
|
|
* @generated from protobuf message api.ProjectAuthorisation
|
|
*/
|
|
export interface ProjectAuthorisation {
|
|
/**
|
|
* Identifier of the project.
|
|
*
|
|
* @generated from protobuf field: string ProjectID = 1
|
|
*/
|
|
ProjectID: string;
|
|
/**
|
|
* TODO Do we need explicit flags to show if receipt / ship is allowed / forbidden ?
|
|
* Constraints applied for unloading appointment.
|
|
*
|
|
* @generated from protobuf field: api.ProjectConstraint UnloadingConstraint = 2
|
|
*/
|
|
UnloadingConstraint?: ProjectConstraint;
|
|
/**
|
|
* Constraints applied for loading appointment.
|
|
*
|
|
* @generated from protobuf field: api.ProjectConstraint LoadingConstraint = 3
|
|
*/
|
|
LoadingConstraint?: ProjectConstraint;
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.ProjectConstraint
|
|
*/
|
|
export interface ProjectConstraint {
|
|
/**
|
|
* Specific Segmentation constraints applicable for the project.
|
|
*
|
|
* @generated from protobuf field: repeated api.SegmentationFilter SegmentationFilters = 1
|
|
*/
|
|
SegmentationFilters: SegmentationFilter[];
|
|
/**
|
|
* Minimal notice delay to book or cancel an appointment.
|
|
*
|
|
* @generated from protobuf field: api.Period MinNoticePeriod = 2
|
|
*/
|
|
MinNoticePeriod?: Period;
|
|
/**
|
|
* Maximal delay to book an appointment.
|
|
*
|
|
* @generated from protobuf field: api.Period MaxBookingPeriod = 3
|
|
*/
|
|
MaxBookingPeriod?: Period;
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.ActorAuthorisation
|
|
*/
|
|
export interface ActorAuthorisation {
|
|
// TODO Do we need explicit flags to show if receipt / ship is allowed / forbidden ?
|
|
|
|
/**
|
|
* Constraints applied for unloading appointment.
|
|
*
|
|
* @generated from protobuf field: api.ActorConstraint UnloadingConstraint = 3
|
|
*/
|
|
UnloadingConstraint?: ActorConstraint;
|
|
/**
|
|
* Constraints applied for loading appointment.
|
|
*
|
|
* @generated from protobuf field: api.ActorConstraint LoadingConstraint = 4
|
|
*/
|
|
LoadingConstraint?: ActorConstraint;
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.ActorConstraint
|
|
*/
|
|
export interface ActorConstraint {
|
|
/**
|
|
* Specific Segmentation constraints applicable for the project.
|
|
*
|
|
* @generated from protobuf field: repeated api.SegmentationActorConstraint SegmentationConstraints = 1
|
|
*/
|
|
SegmentationConstraints: SegmentationActorConstraint[];
|
|
/**
|
|
* Maximal delay to book an appointment
|
|
*
|
|
* @generated from protobuf field: api.Period MaxBookingPeriod = 3
|
|
*/
|
|
MaxBookingPeriod?: Period;
|
|
/**
|
|
* Enable booking for unknown users
|
|
*
|
|
* @generated from protobuf field: bool IsBookingEnabledForUnknownUsers = 4
|
|
*/
|
|
IsBookingEnabledForUnknownUsers: boolean;
|
|
/**
|
|
* CommandIdentifierEntry
|
|
*
|
|
* @generated from protobuf field: api.CommandIdentifierEntry CommandIdentifierEntry = 5
|
|
*/
|
|
CommandIdentifierEntry: CommandIdentifierEntry;
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.SegmentationActorConstraint
|
|
*/
|
|
export interface SegmentationActorConstraint {
|
|
// TODO Need to add here all the Segmentation definition by language
|
|
// in order to avoid to have to retrieve the site payload to display Segmentation values
|
|
|
|
/**
|
|
* Identifier of the Segmentation key to constraint.
|
|
*
|
|
* @generated from protobuf field: string SegmentationID = 1
|
|
*/
|
|
SegmentationID: string;
|
|
/**
|
|
* If some Segmentation values are restricted, define here the identifiers to keep.
|
|
*
|
|
* @generated from protobuf field: repeated string RestrictedValueIDs = 2
|
|
*/
|
|
RestrictedValueIDs: string[];
|
|
/**
|
|
* Define the type of restriction applied on the Segmentation key.
|
|
*
|
|
* @generated from protobuf field: api.SegmentationConstraintType Type = 4
|
|
*/
|
|
Type: SegmentationConstraintType;
|
|
/**
|
|
* In case of order attribute choice, to define the attribute path.
|
|
*
|
|
* @generated from protobuf field: string AttributePath = 5
|
|
*/
|
|
AttributePath: string;
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.AppointmentCommission
|
|
*/
|
|
export interface AppointmentCommission {
|
|
/**
|
|
* @generated from protobuf field: string ProjectID = 1
|
|
*/
|
|
ProjectID: string; // Identifier for the project associated with the order.
|
|
/**
|
|
* @generated from protobuf field: string OrderID = 2
|
|
*/
|
|
OrderID: string; // ID of the order, might be null for standalone.
|
|
/**
|
|
* @generated from protobuf field: string ExecutionflowID = 6
|
|
*/
|
|
ExecutionflowID: string; // ID of the executionflow, might be null for standalone.
|
|
/**
|
|
* @generated from protobuf field: repeated api.QuantityByUnit Quantities = 3
|
|
*/
|
|
Quantities: QuantityByUnit[]; // Volumetry inside the truck, should have at least one item listed.
|
|
/**
|
|
* @generated from protobuf field: string OrganisationID = 4
|
|
*/
|
|
OrganisationID: string; // ID of the organisation.
|
|
/**
|
|
* @generated from protobuf field: string PartnerAppID = 5
|
|
*/
|
|
PartnerAppID: string; // ID of the partnerAppID to notify for the appointment commission
|
|
/**
|
|
* @generated from protobuf field: string ActorID = 7
|
|
*/
|
|
ActorID: string; // ID of the actorID which linked the site on the project commission
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.Commission
|
|
*/
|
|
export interface Commission {
|
|
/**
|
|
* @generated from protobuf field: string ProjectID = 1
|
|
*/
|
|
ProjectID: string; // Identifier for the project associated with the order.
|
|
/**
|
|
* @generated from protobuf field: string OrderID = 2
|
|
*/
|
|
OrderID: string; // ID of the order, might be null for standalone.
|
|
/**
|
|
* @generated from protobuf field: string ExecutionflowID = 5
|
|
*/
|
|
ExecutionflowID: string; // ID of the executionflow, might be null for standalone.
|
|
/**
|
|
* @generated from protobuf field: repeated api.QuantityByUnit Quantities = 3
|
|
*/
|
|
Quantities: QuantityByUnit[]; // Volumetry inside the truck, should have at least one item listed.
|
|
/**
|
|
* @generated from protobuf field: string ActorID = 4
|
|
*/
|
|
ActorID: string; // Identifier for the project associated with the order.
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.WMSCommission
|
|
*/
|
|
export interface WMSCommission {
|
|
/**
|
|
* @generated from protobuf field: string ProjectID = 1
|
|
*/
|
|
ProjectID: string; // Identifier for the project associated with the order.
|
|
/**
|
|
* @generated from protobuf field: string OrderID = 2
|
|
*/
|
|
OrderID: string; // ID of the order, might be null for standalone.
|
|
/**
|
|
* @generated from protobuf field: string ExecutionflowID = 5
|
|
*/
|
|
ExecutionflowID: string; // ID of the executionflow, will be retrieved .
|
|
/**
|
|
* @generated from protobuf field: string ActorID = 4
|
|
*/
|
|
ActorID: string; // Identifier for the project associated with the order.
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.Booking
|
|
*/
|
|
export interface Booking {
|
|
/**
|
|
* @generated from protobuf field: api.AppointmentType AppointmentType = 1
|
|
*/
|
|
AppointmentType: AppointmentType;
|
|
/**
|
|
* @generated from protobuf field: repeated api.Commission Commissions = 2
|
|
*/
|
|
Commissions: Commission[];
|
|
/**
|
|
* @generated from protobuf field: repeated api.SegmentationSelection SegmentationSelections = 3
|
|
*/
|
|
SegmentationSelections: SegmentationSelection[];
|
|
/**
|
|
* @generated from protobuf field: repeated api.Slot Slots = 4
|
|
*/
|
|
Slots: Slot[];
|
|
/**
|
|
* @generated from protobuf field: string AppointmentKind = 5
|
|
*/
|
|
AppointmentKind: string;
|
|
/**
|
|
* @generated from protobuf field: bool HasReference = 6
|
|
*/
|
|
HasReference: boolean;
|
|
/**
|
|
* @generated from protobuf field: repeated string Emails = 7
|
|
*/
|
|
Emails: string[];
|
|
}
|
|
/**
|
|
* @generated from protobuf message api.SlotGroup
|
|
*/
|
|
export interface SlotGroup {
|
|
/**
|
|
* @generated from protobuf field: repeated api.Slot Slots = 1
|
|
*/
|
|
Slots: Slot[]; // List of slots belonging to the group.
|
|
/**
|
|
* @generated from protobuf field: int32 Availability = 2
|
|
*/
|
|
Availability: number; // Availability of the slot group according to site configuration and current bookings -1 to 100 (-1: closed, 0: no longer available, 100: fully available).
|
|
}
|
|
/**
|
|
* @generated from protobuf enum api.AppointmentType
|
|
*/
|
|
export enum AppointmentType {
|
|
/**
|
|
* @generated from protobuf enum value: APPOINTMENT_TYPE_UNKNOWN = 0;
|
|
*/
|
|
APPOINTMENT_TYPE_UNKNOWN = 0,
|
|
/**
|
|
* @generated from protobuf enum value: APPOINTMENT_TYPE_LOADING = 1;
|
|
*/
|
|
APPOINTMENT_TYPE_LOADING = 1,
|
|
/**
|
|
* @generated from protobuf enum value: APPOINTMENT_TYPE_UNLOADING = 2;
|
|
*/
|
|
APPOINTMENT_TYPE_UNLOADING = 2,
|
|
/**
|
|
* @generated from protobuf enum value: APPOINTMENT_TYPE_UNDEFINED = 3;
|
|
*/
|
|
APPOINTMENT_TYPE_UNDEFINED = 3,
|
|
/**
|
|
* @generated from protobuf enum value: APPOINTMENT_TYPE_BOTH = 4;
|
|
*/
|
|
APPOINTMENT_TYPE_BOTH = 4
|
|
}
|
|
/**
|
|
* @generated from protobuf enum api.CapacityRuleScope
|
|
*/
|
|
export enum CapacityRuleScope {
|
|
/**
|
|
* @generated from protobuf enum value: CAPACITY_RULE_SCOPE_UNKNOWN = 0;
|
|
*/
|
|
CAPACITY_RULE_SCOPE_UNKNOWN = 0,
|
|
/**
|
|
* @generated from protobuf enum value: CAPACITY_RULE_SCOPE_SIMULTANEOUS = 1;
|
|
*/
|
|
CAPACITY_RULE_SCOPE_SIMULTANEOUS = 1,
|
|
/**
|
|
* @generated from protobuf enum value: CAPACITY_RULE_SCOPE_DAILY = 2;
|
|
*/
|
|
CAPACITY_RULE_SCOPE_DAILY = 2
|
|
}
|
|
/**
|
|
* @generated from protobuf enum api.CommandIdentifierEntry
|
|
*/
|
|
export enum CommandIdentifierEntry {
|
|
/**
|
|
* @generated from protobuf enum value: CommandIdentifierEntry_MandatoryExceptForAllowedUsers = 0;
|
|
*/
|
|
CommandIdentifierEntry_MandatoryExceptForAllowedUsers = 0,
|
|
/**
|
|
* @generated from protobuf enum value: CommandIdentifierEntry_NoRef = 1;
|
|
*/
|
|
CommandIdentifierEntry_NoRef = 1
|
|
}
|
|
/**
|
|
* @generated from protobuf enum api.SegmentationConstraintType
|
|
*/
|
|
export enum SegmentationConstraintType {
|
|
/**
|
|
* @generated from protobuf enum value: SEGMENTATION_CONSTRAINT_TYPE_UNKNOWN = 0;
|
|
*/
|
|
SEGMENTATION_CONSTRAINT_TYPE_UNKNOWN = 0,
|
|
/**
|
|
* @generated from protobuf enum value: SEGMENTATION_CONSTRAINT_TYPE_USER_CHOICE = 1;
|
|
*/
|
|
SEGMENTATION_CONSTRAINT_TYPE_USER_CHOICE = 1,
|
|
/**
|
|
* SEGMENTATION_CONSTRAINT_TYPE_ENFORCED = 3;
|
|
*
|
|
* @generated from protobuf enum value: SEGMENTATION_CONSTRAINT_TYPE_ORDER_ATTRIBUTE = 2;
|
|
*/
|
|
SEGMENTATION_CONSTRAINT_TYPE_ORDER_ATTRIBUTE = 2
|
|
}
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class Unit$Type extends MessageType<Unit> {
|
|
constructor() {
|
|
super("api.Unit", [
|
|
{ no: 1, name: "UnitID", kind: "scalar", localName: "UnitID", jsonName: "UnitID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "Labels", kind: "message", localName: "Labels", jsonName: "Labels", repeat: 2 /*RepeatType.UNPACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<Unit>): Unit {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.UnitID = "";
|
|
message.Labels = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<Unit>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Unit): Unit {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string UnitID */ 1:
|
|
message.UnitID = reader.string();
|
|
break;
|
|
case /* repeated api.LabelByLanguage Labels */ 2:
|
|
message.Labels.push(LabelByLanguage.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: Unit, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string UnitID = 1; */
|
|
if (message.UnitID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.UnitID);
|
|
/* repeated api.LabelByLanguage Labels = 2; */
|
|
for (let i = 0; i < message.Labels.length; i++)
|
|
LabelByLanguage.internalBinaryWrite(message.Labels[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.Unit
|
|
*/
|
|
export const Unit = new Unit$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class QuantityByUnit$Type extends MessageType<QuantityByUnit> {
|
|
constructor() {
|
|
super("api.QuantityByUnit", [
|
|
{ no: 1, name: "UnitID", kind: "scalar", localName: "UnitID", jsonName: "UnitID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "Value", kind: "scalar", localName: "Value", jsonName: "Value", T: 1 /*ScalarType.DOUBLE*/, options: { "validate.rules": { double: { gte: 0 } } } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<QuantityByUnit>): QuantityByUnit {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.UnitID = "";
|
|
message.Value = 0;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<QuantityByUnit>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: QuantityByUnit): QuantityByUnit {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string UnitID */ 1:
|
|
message.UnitID = reader.string();
|
|
break;
|
|
case /* double Value */ 2:
|
|
message.Value = reader.double();
|
|
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: QuantityByUnit, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string UnitID = 1; */
|
|
if (message.UnitID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.UnitID);
|
|
/* double Value = 2; */
|
|
if (message.Value !== 0)
|
|
writer.tag(2, WireType.Bit64).double(message.Value);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.QuantityByUnit
|
|
*/
|
|
export const QuantityByUnit = new QuantityByUnit$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class Slot$Type extends MessageType<Slot> {
|
|
constructor() {
|
|
super("api.Slot", [
|
|
{ no: 1, name: "StartDateTime", kind: "scalar", localName: "StartDateTime", jsonName: "StartDateTime", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])T[01][0-9]|2[0-3]:[0-5][0-9]:[0-5][0-9]$" } }, "api.indexationType": { Types: [{ Context: "*", Type: "date" }] }, "api.viewType": { Types: [{ Context: "*", Type: "date" }] } } },
|
|
{ no: 3, name: "DurationInSeconds", kind: "scalar", localName: "DurationInSeconds", jsonName: "DurationInSeconds", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
|
|
{ no: 4, name: "EndDateTime", kind: "scalar", localName: "EndDateTime", jsonName: "EndDateTime", T: 9 /*ScalarType.STRING*/, options: { "api.indexationType": { Types: [{ Context: "*", Type: "date" }] }, "api.viewType": { Types: [{ Context: "*", Type: "date" }] } } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<Slot>): Slot {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.StartDateTime = "";
|
|
message.DurationInSeconds = 0n;
|
|
message.EndDateTime = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<Slot>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Slot): Slot {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string StartDateTime */ 1:
|
|
message.StartDateTime = reader.string();
|
|
break;
|
|
case /* uint64 DurationInSeconds */ 3:
|
|
message.DurationInSeconds = reader.uint64().toBigInt();
|
|
break;
|
|
case /* string EndDateTime */ 4:
|
|
message.EndDateTime = 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: Slot, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string StartDateTime = 1; */
|
|
if (message.StartDateTime !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.StartDateTime);
|
|
/* uint64 DurationInSeconds = 3; */
|
|
if (message.DurationInSeconds !== 0n)
|
|
writer.tag(3, WireType.Varint).uint64(message.DurationInSeconds);
|
|
/* string EndDateTime = 4; */
|
|
if (message.EndDateTime !== "")
|
|
writer.tag(4, WireType.LengthDelimited).string(message.EndDateTime);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.Slot
|
|
*/
|
|
export const Slot = new Slot$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class Segmentation$Type extends MessageType<Segmentation> {
|
|
constructor() {
|
|
super("api.Segmentation", [
|
|
{ no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1", pattern: "^[a-zA-Z0-9]+$" } } } },
|
|
{ no: 2, name: "SegmentationLabels", kind: "message", localName: "SegmentationLabels", jsonName: "SegmentationLabels", repeat: 2 /*RepeatType.UNPACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } },
|
|
{ no: 3, name: "Values", kind: "message", localName: "Values", jsonName: "Values", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SegmentationValue }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<Segmentation>): Segmentation {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.SegmentationID = "";
|
|
message.SegmentationLabels = [];
|
|
message.Values = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<Segmentation>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Segmentation): Segmentation {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string SegmentationID */ 1:
|
|
message.SegmentationID = reader.string();
|
|
break;
|
|
case /* repeated api.LabelByLanguage SegmentationLabels */ 2:
|
|
message.SegmentationLabels.push(LabelByLanguage.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* repeated api.SegmentationValue Values */ 3:
|
|
message.Values.push(SegmentationValue.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: Segmentation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string SegmentationID = 1; */
|
|
if (message.SegmentationID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
|
|
/* repeated api.LabelByLanguage SegmentationLabels = 2; */
|
|
for (let i = 0; i < message.SegmentationLabels.length; i++)
|
|
LabelByLanguage.internalBinaryWrite(message.SegmentationLabels[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
|
/* repeated api.SegmentationValue Values = 3; */
|
|
for (let i = 0; i < message.Values.length; i++)
|
|
SegmentationValue.internalBinaryWrite(message.Values[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.Segmentation
|
|
*/
|
|
export const Segmentation = new Segmentation$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SegmentationValue$Type extends MessageType<SegmentationValue> {
|
|
constructor() {
|
|
super("api.SegmentationValue", [
|
|
{ no: 1, name: "ID", kind: "scalar", localName: "ID", jsonName: "ID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1", pattern: "^[a-zA-Z0-9]+$" } } } },
|
|
{ no: 2, name: "Labels", kind: "message", localName: "Labels", jsonName: "Labels", repeat: 2 /*RepeatType.UNPACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SegmentationValue>): SegmentationValue {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.ID = "";
|
|
message.Labels = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SegmentationValue>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationValue): SegmentationValue {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string ID */ 1:
|
|
message.ID = reader.string();
|
|
break;
|
|
case /* repeated api.LabelByLanguage Labels */ 2:
|
|
message.Labels.push(LabelByLanguage.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: SegmentationValue, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string ID = 1; */
|
|
if (message.ID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.ID);
|
|
/* repeated api.LabelByLanguage Labels = 2; */
|
|
for (let i = 0; i < message.Labels.length; i++)
|
|
LabelByLanguage.internalBinaryWrite(message.Labels[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.SegmentationValue
|
|
*/
|
|
export const SegmentationValue = new SegmentationValue$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class Instruction$Type extends MessageType<Instruction> {
|
|
constructor() {
|
|
super("api.Instruction", [
|
|
{ no: 15, name: "InstructionByLanguage", kind: "message", localName: "InstructionByLanguage", jsonName: "InstructionByLanguage", repeat: 2 /*RepeatType.UNPACKED*/, T: () => LabelByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } },
|
|
{ no: 2, name: "AckRequired", kind: "scalar", localName: "AckRequired", jsonName: "AckRequired", T: 8 /*ScalarType.BOOL*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<Instruction>): Instruction {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.InstructionByLanguage = [];
|
|
message.AckRequired = false;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<Instruction>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Instruction): Instruction {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* repeated api.LabelByLanguage InstructionByLanguage */ 15:
|
|
message.InstructionByLanguage.push(LabelByLanguage.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* bool AckRequired */ 2:
|
|
message.AckRequired = reader.bool();
|
|
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: Instruction, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* bool AckRequired = 2; */
|
|
if (message.AckRequired !== false)
|
|
writer.tag(2, WireType.Varint).bool(message.AckRequired);
|
|
/* repeated api.LabelByLanguage InstructionByLanguage = 15; */
|
|
for (let i = 0; i < message.InstructionByLanguage.length; i++)
|
|
LabelByLanguage.internalBinaryWrite(message.InstructionByLanguage[i], writer.tag(15, 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.Instruction
|
|
*/
|
|
export const Instruction = new Instruction$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class OpeningRule$Type extends MessageType<OpeningRule> {
|
|
constructor() {
|
|
super("api.OpeningRule", [
|
|
{ no: 1, name: "StartDate", kind: "scalar", localName: "StartDate", jsonName: "StartDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
|
|
{ no: 2, name: "EndDate", kind: "scalar", localName: "EndDate", jsonName: "EndDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
|
|
{ no: 3, name: "OpeningDays", kind: "message", localName: "OpeningDays", jsonName: "OpeningDays", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OpeningDay, options: { "api.aggKey": "WeekDay" } },
|
|
{ no: 4, name: "CalendarID", kind: "scalar", localName: "CalendarID", jsonName: "CalendarID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 5, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<OpeningRule>): OpeningRule {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.StartDate = "";
|
|
message.EndDate = "";
|
|
message.OpeningDays = [];
|
|
message.CalendarID = "";
|
|
message.Label = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<OpeningRule>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OpeningRule): OpeningRule {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string StartDate */ 1:
|
|
message.StartDate = reader.string();
|
|
break;
|
|
case /* string EndDate */ 2:
|
|
message.EndDate = reader.string();
|
|
break;
|
|
case /* repeated api.OpeningDay OpeningDays */ 3:
|
|
message.OpeningDays.push(OpeningDay.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* string CalendarID */ 4:
|
|
message.CalendarID = reader.string();
|
|
break;
|
|
case /* string Label */ 5:
|
|
message.Label = 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: OpeningRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string StartDate = 1; */
|
|
if (message.StartDate !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.StartDate);
|
|
/* string EndDate = 2; */
|
|
if (message.EndDate !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.EndDate);
|
|
/* repeated api.OpeningDay OpeningDays = 3; */
|
|
for (let i = 0; i < message.OpeningDays.length; i++)
|
|
OpeningDay.internalBinaryWrite(message.OpeningDays[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* string CalendarID = 4; */
|
|
if (message.CalendarID !== "")
|
|
writer.tag(4, WireType.LengthDelimited).string(message.CalendarID);
|
|
/* string Label = 5; */
|
|
if (message.Label !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.Label);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.OpeningRule
|
|
*/
|
|
export const OpeningRule = new OpeningRule$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class OpeningDay$Type extends MessageType<OpeningDay> {
|
|
constructor() {
|
|
super("api.OpeningDay", [
|
|
{ no: 1, name: "WeekDay", kind: "enum", localName: "WeekDay", jsonName: "WeekDay", T: () => ["api.WeekDay", WeekDay] },
|
|
{ no: 2, name: "Definitions", kind: "message", localName: "Definitions", jsonName: "Definitions", repeat: 2 /*RepeatType.UNPACKED*/, T: () => OpeningDayDefinition }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<OpeningDay>): OpeningDay {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.WeekDay = 0;
|
|
message.Definitions = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<OpeningDay>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OpeningDay): OpeningDay {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* api.WeekDay WeekDay */ 1:
|
|
message.WeekDay = reader.int32();
|
|
break;
|
|
case /* repeated api.OpeningDayDefinition Definitions */ 2:
|
|
message.Definitions.push(OpeningDayDefinition.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: OpeningDay, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* api.WeekDay WeekDay = 1; */
|
|
if (message.WeekDay !== 0)
|
|
writer.tag(1, WireType.Varint).int32(message.WeekDay);
|
|
/* repeated api.OpeningDayDefinition Definitions = 2; */
|
|
for (let i = 0; i < message.Definitions.length; i++)
|
|
OpeningDayDefinition.internalBinaryWrite(message.Definitions[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.OpeningDay
|
|
*/
|
|
export const OpeningDay = new OpeningDay$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class OpeningDayDefinition$Type extends MessageType<OpeningDayDefinition> {
|
|
constructor() {
|
|
super("api.OpeningDayDefinition", [
|
|
{ no: 2, name: "TimeRanges", kind: "message", localName: "TimeRanges", jsonName: "TimeRanges", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TimeRange },
|
|
{ no: 3, name: "Filter", kind: "message", localName: "Filter", jsonName: "Filter", T: () => RuleFilter },
|
|
{ no: 4, name: "OrderAppliance", kind: "scalar", localName: "OrderAppliance", jsonName: "OrderAppliance", T: 5 /*ScalarType.INT32*/ },
|
|
{ no: 5, name: "ApplyCalendarTimetable", kind: "scalar", localName: "ApplyCalendarTimetable", jsonName: "ApplyCalendarTimetable", T: 8 /*ScalarType.BOOL*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<OpeningDayDefinition>): OpeningDayDefinition {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.TimeRanges = [];
|
|
message.OrderAppliance = 0;
|
|
message.ApplyCalendarTimetable = false;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<OpeningDayDefinition>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: OpeningDayDefinition): OpeningDayDefinition {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* repeated api.TimeRange TimeRanges */ 2:
|
|
message.TimeRanges.push(TimeRange.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* api.RuleFilter Filter */ 3:
|
|
message.Filter = RuleFilter.internalBinaryRead(reader, reader.uint32(), options, message.Filter);
|
|
break;
|
|
case /* int32 OrderAppliance */ 4:
|
|
message.OrderAppliance = reader.int32();
|
|
break;
|
|
case /* bool ApplyCalendarTimetable */ 5:
|
|
message.ApplyCalendarTimetable = reader.bool();
|
|
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: OpeningDayDefinition, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* repeated api.TimeRange TimeRanges = 2; */
|
|
for (let i = 0; i < message.TimeRanges.length; i++)
|
|
TimeRange.internalBinaryWrite(message.TimeRanges[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
|
/* api.RuleFilter Filter = 3; */
|
|
if (message.Filter)
|
|
RuleFilter.internalBinaryWrite(message.Filter, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* int32 OrderAppliance = 4; */
|
|
if (message.OrderAppliance !== 0)
|
|
writer.tag(4, WireType.Varint).int32(message.OrderAppliance);
|
|
/* bool ApplyCalendarTimetable = 5; */
|
|
if (message.ApplyCalendarTimetable !== false)
|
|
writer.tag(5, WireType.Varint).bool(message.ApplyCalendarTimetable);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.OpeningDayDefinition
|
|
*/
|
|
export const OpeningDayDefinition = new OpeningDayDefinition$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class CapacityRule$Type extends MessageType<CapacityRule> {
|
|
constructor() {
|
|
super("api.CapacityRule", [
|
|
{ no: 1, name: "StartDate", kind: "scalar", localName: "StartDate", jsonName: "StartDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
|
|
{ no: 2, name: "EndDate", kind: "scalar", localName: "EndDate", jsonName: "EndDate", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { pattern: "^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$" } } } },
|
|
{ no: 5, name: "Label", kind: "scalar", localName: "Label", jsonName: "Label", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 3, name: "Days", kind: "enum", localName: "Days", jsonName: "Days", repeat: 1 /*RepeatType.PACKED*/, T: () => ["api.WeekDay", WeekDay] },
|
|
{ no: 4, name: "Capacities", kind: "message", localName: "Capacities", jsonName: "Capacities", repeat: 2 /*RepeatType.UNPACKED*/, T: () => CapacityDefinition }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<CapacityRule>): CapacityRule {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.StartDate = "";
|
|
message.EndDate = "";
|
|
message.Label = "";
|
|
message.Days = [];
|
|
message.Capacities = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<CapacityRule>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CapacityRule): CapacityRule {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string StartDate */ 1:
|
|
message.StartDate = reader.string();
|
|
break;
|
|
case /* string EndDate */ 2:
|
|
message.EndDate = reader.string();
|
|
break;
|
|
case /* string Label */ 5:
|
|
message.Label = reader.string();
|
|
break;
|
|
case /* repeated api.WeekDay Days */ 3:
|
|
if (wireType === WireType.LengthDelimited)
|
|
for (let e = reader.int32() + reader.pos; reader.pos < e;)
|
|
message.Days.push(reader.int32());
|
|
else
|
|
message.Days.push(reader.int32());
|
|
break;
|
|
case /* repeated api.CapacityDefinition Capacities */ 4:
|
|
message.Capacities.push(CapacityDefinition.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: CapacityRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string StartDate = 1; */
|
|
if (message.StartDate !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.StartDate);
|
|
/* string EndDate = 2; */
|
|
if (message.EndDate !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.EndDate);
|
|
/* repeated api.WeekDay Days = 3; */
|
|
if (message.Days.length) {
|
|
writer.tag(3, WireType.LengthDelimited).fork();
|
|
for (let i = 0; i < message.Days.length; i++)
|
|
writer.int32(message.Days[i]);
|
|
writer.join();
|
|
}
|
|
/* repeated api.CapacityDefinition Capacities = 4; */
|
|
for (let i = 0; i < message.Capacities.length; i++)
|
|
CapacityDefinition.internalBinaryWrite(message.Capacities[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
|
|
/* string Label = 5; */
|
|
if (message.Label !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.Label);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.CapacityRule
|
|
*/
|
|
export const CapacityRule = new CapacityRule$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class CapacityDefinition$Type extends MessageType<CapacityDefinition> {
|
|
constructor() {
|
|
super("api.CapacityDefinition", [
|
|
{ no: 1, name: "Filter", kind: "message", localName: "Filter", jsonName: "Filter", T: () => RuleFilter },
|
|
{ no: 2, name: "Scope", kind: "enum", localName: "Scope", jsonName: "Scope", T: () => ["api.CapacityRuleScope", CapacityRuleScope] },
|
|
{ no: 3, name: "MaximalCapacity", kind: "scalar", localName: "MaximalCapacity", jsonName: "MaximalCapacity", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
|
|
{ no: 4, name: "UnitID", kind: "scalar", localName: "UnitID", jsonName: "UnitID", T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<CapacityDefinition>): CapacityDefinition {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.Scope = 0;
|
|
message.MaximalCapacity = 0n;
|
|
message.UnitID = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<CapacityDefinition>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: CapacityDefinition): CapacityDefinition {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* api.RuleFilter Filter */ 1:
|
|
message.Filter = RuleFilter.internalBinaryRead(reader, reader.uint32(), options, message.Filter);
|
|
break;
|
|
case /* api.CapacityRuleScope Scope */ 2:
|
|
message.Scope = reader.int32();
|
|
break;
|
|
case /* int64 MaximalCapacity */ 3:
|
|
message.MaximalCapacity = reader.int64().toBigInt();
|
|
break;
|
|
case /* string UnitID */ 4:
|
|
message.UnitID = 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: CapacityDefinition, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* api.RuleFilter Filter = 1; */
|
|
if (message.Filter)
|
|
RuleFilter.internalBinaryWrite(message.Filter, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
|
/* api.CapacityRuleScope Scope = 2; */
|
|
if (message.Scope !== 0)
|
|
writer.tag(2, WireType.Varint).int32(message.Scope);
|
|
/* int64 MaximalCapacity = 3; */
|
|
if (message.MaximalCapacity !== 0n)
|
|
writer.tag(3, WireType.Varint).int64(message.MaximalCapacity);
|
|
/* string UnitID = 4; */
|
|
if (message.UnitID !== "")
|
|
writer.tag(4, WireType.LengthDelimited).string(message.UnitID);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.CapacityDefinition
|
|
*/
|
|
export const CapacityDefinition = new CapacityDefinition$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class DurationRule$Type extends MessageType<DurationRule> {
|
|
constructor() {
|
|
super("api.DurationRule", [
|
|
{ no: 1, name: "Filter", kind: "message", localName: "Filter", jsonName: "Filter", T: () => RuleFilter },
|
|
{ no: 2, name: "BaseDurationInSeconds", kind: "scalar", localName: "BaseDurationInSeconds", jsonName: "BaseDurationInSeconds", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
|
|
{ no: 3, name: "VariableDurations", kind: "message", localName: "VariableDurations", jsonName: "VariableDurations", repeat: 2 /*RepeatType.UNPACKED*/, T: () => VariableDuration, options: { "api.aggKey": "UnitID" } },
|
|
{ no: 4, name: "OrderAppliance", kind: "scalar", localName: "OrderAppliance", jsonName: "OrderAppliance", T: 5 /*ScalarType.INT32*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<DurationRule>): DurationRule {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.BaseDurationInSeconds = 0n;
|
|
message.VariableDurations = [];
|
|
message.OrderAppliance = 0;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<DurationRule>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DurationRule): DurationRule {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* api.RuleFilter Filter */ 1:
|
|
message.Filter = RuleFilter.internalBinaryRead(reader, reader.uint32(), options, message.Filter);
|
|
break;
|
|
case /* uint64 BaseDurationInSeconds */ 2:
|
|
message.BaseDurationInSeconds = reader.uint64().toBigInt();
|
|
break;
|
|
case /* repeated api.VariableDuration VariableDurations */ 3:
|
|
message.VariableDurations.push(VariableDuration.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* int32 OrderAppliance */ 4:
|
|
message.OrderAppliance = reader.int32();
|
|
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: DurationRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* api.RuleFilter Filter = 1; */
|
|
if (message.Filter)
|
|
RuleFilter.internalBinaryWrite(message.Filter, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
|
/* uint64 BaseDurationInSeconds = 2; */
|
|
if (message.BaseDurationInSeconds !== 0n)
|
|
writer.tag(2, WireType.Varint).uint64(message.BaseDurationInSeconds);
|
|
/* repeated api.VariableDuration VariableDurations = 3; */
|
|
for (let i = 0; i < message.VariableDurations.length; i++)
|
|
VariableDuration.internalBinaryWrite(message.VariableDurations[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* int32 OrderAppliance = 4; */
|
|
if (message.OrderAppliance !== 0)
|
|
writer.tag(4, WireType.Varint).int32(message.OrderAppliance);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.DurationRule
|
|
*/
|
|
export const DurationRule = new DurationRule$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class VariableDuration$Type extends MessageType<VariableDuration> {
|
|
constructor() {
|
|
super("api.VariableDuration", [
|
|
{ no: 1, name: "UnitID", kind: "scalar", localName: "UnitID", jsonName: "UnitID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "DurationInSeconds", kind: "scalar", localName: "DurationInSeconds", jsonName: "DurationInSeconds", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<VariableDuration>): VariableDuration {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.UnitID = "";
|
|
message.DurationInSeconds = 0n;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<VariableDuration>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VariableDuration): VariableDuration {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string UnitID */ 1:
|
|
message.UnitID = reader.string();
|
|
break;
|
|
case /* uint64 DurationInSeconds */ 2:
|
|
message.DurationInSeconds = reader.uint64().toBigInt();
|
|
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: VariableDuration, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string UnitID = 1; */
|
|
if (message.UnitID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.UnitID);
|
|
/* uint64 DurationInSeconds = 2; */
|
|
if (message.DurationInSeconds !== 0n)
|
|
writer.tag(2, WireType.Varint).uint64(message.DurationInSeconds);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.VariableDuration
|
|
*/
|
|
export const VariableDuration = new VariableDuration$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class RuleFilter$Type extends MessageType<RuleFilter> {
|
|
constructor() {
|
|
super("api.RuleFilter", [
|
|
{ no: 1, name: "Type", kind: "enum", localName: "Type", jsonName: "Type", T: () => ["api.AppointmentType", AppointmentType] },
|
|
{ no: 2, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 3, name: "SegmentationKeys", kind: "message", localName: "SegmentationKeys", jsonName: "SegmentationKeys", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SegmentationFilter }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<RuleFilter>): RuleFilter {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.Type = 0;
|
|
message.ProjectID = [];
|
|
message.SegmentationKeys = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<RuleFilter>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: RuleFilter): RuleFilter {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* api.AppointmentType Type */ 1:
|
|
message.Type = reader.int32();
|
|
break;
|
|
case /* repeated string ProjectID */ 2:
|
|
message.ProjectID.push(reader.string());
|
|
break;
|
|
case /* repeated api.SegmentationFilter SegmentationKeys */ 3:
|
|
message.SegmentationKeys.push(SegmentationFilter.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: RuleFilter, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* api.AppointmentType Type = 1; */
|
|
if (message.Type !== 0)
|
|
writer.tag(1, WireType.Varint).int32(message.Type);
|
|
/* repeated string ProjectID = 2; */
|
|
for (let i = 0; i < message.ProjectID.length; i++)
|
|
writer.tag(2, WireType.LengthDelimited).string(message.ProjectID[i]);
|
|
/* repeated api.SegmentationFilter SegmentationKeys = 3; */
|
|
for (let i = 0; i < message.SegmentationKeys.length; i++)
|
|
SegmentationFilter.internalBinaryWrite(message.SegmentationKeys[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.RuleFilter
|
|
*/
|
|
export const RuleFilter = new RuleFilter$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SegmentationFilter$Type extends MessageType<SegmentationFilter> {
|
|
constructor() {
|
|
super("api.SegmentationFilter", [
|
|
{ no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "SegmentationValueIDs", kind: "scalar", localName: "SegmentationValueIDs", jsonName: "SegmentationValueIDs", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SegmentationFilter>): SegmentationFilter {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.SegmentationID = "";
|
|
message.SegmentationValueIDs = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SegmentationFilter>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationFilter): SegmentationFilter {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string SegmentationID */ 1:
|
|
message.SegmentationID = reader.string();
|
|
break;
|
|
case /* repeated string SegmentationValueIDs */ 2:
|
|
message.SegmentationValueIDs.push(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: SegmentationFilter, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string SegmentationID = 1; */
|
|
if (message.SegmentationID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
|
|
/* repeated string SegmentationValueIDs = 2; */
|
|
for (let i = 0; i < message.SegmentationValueIDs.length; i++)
|
|
writer.tag(2, WireType.LengthDelimited).string(message.SegmentationValueIDs[i]);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.SegmentationFilter
|
|
*/
|
|
export const SegmentationFilter = new SegmentationFilter$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SegmentationSelection$Type extends MessageType<SegmentationSelection> {
|
|
constructor() {
|
|
super("api.SegmentationSelection", [
|
|
{ no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "SegmentationValueID", kind: "scalar", localName: "SegmentationValueID", jsonName: "SegmentationValueID", T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SegmentationSelection>): SegmentationSelection {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.SegmentationID = "";
|
|
message.SegmentationValueID = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SegmentationSelection>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationSelection): SegmentationSelection {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string SegmentationID */ 1:
|
|
message.SegmentationID = reader.string();
|
|
break;
|
|
case /* string SegmentationValueID */ 2:
|
|
message.SegmentationValueID = 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: SegmentationSelection, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string SegmentationID = 1; */
|
|
if (message.SegmentationID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
|
|
/* string SegmentationValueID = 2; */
|
|
if (message.SegmentationValueID !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.SegmentationValueID);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.SegmentationSelection
|
|
*/
|
|
export const SegmentationSelection = new SegmentationSelection$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class Document$Type extends MessageType<Document> {
|
|
constructor() {
|
|
super("api.Document", [
|
|
{ no: 1, name: "DocID", kind: "scalar", localName: "DocID", jsonName: "DocID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "DocsByLang", kind: "message", localName: "DocsByLang", jsonName: "DocsByLang", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DocumentByLanguage, options: { "api.language": true, "api.aggKey": "LanguageCodeISO6391" } },
|
|
{ no: 3, name: "AckRequired", kind: "scalar", localName: "AckRequired", jsonName: "AckRequired", T: 8 /*ScalarType.BOOL*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<Document>): Document {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.DocID = "";
|
|
message.DocsByLang = [];
|
|
message.AckRequired = false;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<Document>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Document): Document {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string DocID */ 1:
|
|
message.DocID = reader.string();
|
|
break;
|
|
case /* repeated api.DocumentByLanguage DocsByLang */ 2:
|
|
message.DocsByLang.push(DocumentByLanguage.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* bool AckRequired */ 3:
|
|
message.AckRequired = reader.bool();
|
|
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: Document, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string DocID = 1; */
|
|
if (message.DocID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.DocID);
|
|
/* repeated api.DocumentByLanguage DocsByLang = 2; */
|
|
for (let i = 0; i < message.DocsByLang.length; i++)
|
|
DocumentByLanguage.internalBinaryWrite(message.DocsByLang[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
|
/* bool AckRequired = 3; */
|
|
if (message.AckRequired !== false)
|
|
writer.tag(3, WireType.Varint).bool(message.AckRequired);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.Document
|
|
*/
|
|
export const Document = new Document$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class DocumentByLanguage$Type extends MessageType<DocumentByLanguage> {
|
|
constructor() {
|
|
super("api.DocumentByLanguage", [
|
|
{ no: 1, name: "Name", kind: "scalar", localName: "Name", jsonName: "Name", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 4, name: "URI", kind: "scalar", localName: "URI", jsonName: "URI", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "URI of the document" } } },
|
|
{ no: 3, name: "LanguageCodeISO6391", kind: "scalar", localName: "LanguageCodeISO6391", 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\"" } } },
|
|
{ no: 5, name: "FileName", kind: "scalar", localName: "FileName", jsonName: "FileName", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 6, name: "LongURI", kind: "scalar", localName: "LongURI", jsonName: "LongURI", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } }, "grpc.gateway.protoc_gen_openapiv2.options.openapiv2_field": { description: "Long URI of the document containing the file name in order to display the file name in a tab browser" } } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<DocumentByLanguage>): DocumentByLanguage {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.Name = "";
|
|
message.URI = "";
|
|
message.LanguageCodeISO6391 = "";
|
|
message.FileName = "";
|
|
message.LongURI = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<DocumentByLanguage>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DocumentByLanguage): DocumentByLanguage {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string Name */ 1:
|
|
message.Name = reader.string();
|
|
break;
|
|
case /* string URI */ 4:
|
|
message.URI = reader.string();
|
|
break;
|
|
case /* string LanguageCodeISO6391 */ 3:
|
|
message.LanguageCodeISO6391 = reader.string();
|
|
break;
|
|
case /* string FileName */ 5:
|
|
message.FileName = reader.string();
|
|
break;
|
|
case /* string LongURI */ 6:
|
|
message.LongURI = 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: DocumentByLanguage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string Name = 1; */
|
|
if (message.Name !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.Name);
|
|
/* string LanguageCodeISO6391 = 3; */
|
|
if (message.LanguageCodeISO6391 !== "")
|
|
writer.tag(3, WireType.LengthDelimited).string(message.LanguageCodeISO6391);
|
|
/* string URI = 4; */
|
|
if (message.URI !== "")
|
|
writer.tag(4, WireType.LengthDelimited).string(message.URI);
|
|
/* string FileName = 5; */
|
|
if (message.FileName !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.FileName);
|
|
/* string LongURI = 6; */
|
|
if (message.LongURI !== "")
|
|
writer.tag(6, WireType.LengthDelimited).string(message.LongURI);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.DocumentByLanguage
|
|
*/
|
|
export const DocumentByLanguage = new DocumentByLanguage$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class ProjectAuthorisation$Type extends MessageType<ProjectAuthorisation> {
|
|
constructor() {
|
|
super("api.ProjectAuthorisation", [
|
|
{ no: 1, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 2, name: "UnloadingConstraint", kind: "message", localName: "UnloadingConstraint", jsonName: "UnloadingConstraint", T: () => ProjectConstraint },
|
|
{ no: 3, name: "LoadingConstraint", kind: "message", localName: "LoadingConstraint", jsonName: "LoadingConstraint", T: () => ProjectConstraint }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<ProjectAuthorisation>): ProjectAuthorisation {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.ProjectID = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<ProjectAuthorisation>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ProjectAuthorisation): ProjectAuthorisation {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string ProjectID */ 1:
|
|
message.ProjectID = reader.string();
|
|
break;
|
|
case /* api.ProjectConstraint UnloadingConstraint */ 2:
|
|
message.UnloadingConstraint = ProjectConstraint.internalBinaryRead(reader, reader.uint32(), options, message.UnloadingConstraint);
|
|
break;
|
|
case /* api.ProjectConstraint LoadingConstraint */ 3:
|
|
message.LoadingConstraint = ProjectConstraint.internalBinaryRead(reader, reader.uint32(), options, message.LoadingConstraint);
|
|
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: ProjectAuthorisation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string ProjectID = 1; */
|
|
if (message.ProjectID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.ProjectID);
|
|
/* api.ProjectConstraint UnloadingConstraint = 2; */
|
|
if (message.UnloadingConstraint)
|
|
ProjectConstraint.internalBinaryWrite(message.UnloadingConstraint, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
|
/* api.ProjectConstraint LoadingConstraint = 3; */
|
|
if (message.LoadingConstraint)
|
|
ProjectConstraint.internalBinaryWrite(message.LoadingConstraint, 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.ProjectAuthorisation
|
|
*/
|
|
export const ProjectAuthorisation = new ProjectAuthorisation$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class ProjectConstraint$Type extends MessageType<ProjectConstraint> {
|
|
constructor() {
|
|
super("api.ProjectConstraint", [
|
|
{ no: 1, name: "SegmentationFilters", kind: "message", localName: "SegmentationFilters", jsonName: "SegmentationFilters", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SegmentationFilter, options: { "api.aggKey": "SegmentationID" } },
|
|
{ no: 2, name: "MinNoticePeriod", kind: "message", localName: "MinNoticePeriod", jsonName: "MinNoticePeriod", T: () => Period },
|
|
{ no: 3, name: "MaxBookingPeriod", kind: "message", localName: "MaxBookingPeriod", jsonName: "MaxBookingPeriod", T: () => Period }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<ProjectConstraint>): ProjectConstraint {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.SegmentationFilters = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<ProjectConstraint>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ProjectConstraint): ProjectConstraint {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* repeated api.SegmentationFilter SegmentationFilters */ 1:
|
|
message.SegmentationFilters.push(SegmentationFilter.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* api.Period MinNoticePeriod */ 2:
|
|
message.MinNoticePeriod = Period.internalBinaryRead(reader, reader.uint32(), options, message.MinNoticePeriod);
|
|
break;
|
|
case /* api.Period MaxBookingPeriod */ 3:
|
|
message.MaxBookingPeriod = Period.internalBinaryRead(reader, reader.uint32(), options, message.MaxBookingPeriod);
|
|
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: ProjectConstraint, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* repeated api.SegmentationFilter SegmentationFilters = 1; */
|
|
for (let i = 0; i < message.SegmentationFilters.length; i++)
|
|
SegmentationFilter.internalBinaryWrite(message.SegmentationFilters[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
|
/* api.Period MinNoticePeriod = 2; */
|
|
if (message.MinNoticePeriod)
|
|
Period.internalBinaryWrite(message.MinNoticePeriod, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
|
/* api.Period MaxBookingPeriod = 3; */
|
|
if (message.MaxBookingPeriod)
|
|
Period.internalBinaryWrite(message.MaxBookingPeriod, 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.ProjectConstraint
|
|
*/
|
|
export const ProjectConstraint = new ProjectConstraint$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class ActorAuthorisation$Type extends MessageType<ActorAuthorisation> {
|
|
constructor() {
|
|
super("api.ActorAuthorisation", [
|
|
{ no: 3, name: "UnloadingConstraint", kind: "message", localName: "UnloadingConstraint", jsonName: "UnloadingConstraint", T: () => ActorConstraint },
|
|
{ no: 4, name: "LoadingConstraint", kind: "message", localName: "LoadingConstraint", jsonName: "LoadingConstraint", T: () => ActorConstraint }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<ActorAuthorisation>): ActorAuthorisation {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
if (value !== undefined)
|
|
reflectionMergePartial<ActorAuthorisation>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorAuthorisation): ActorAuthorisation {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* api.ActorConstraint UnloadingConstraint */ 3:
|
|
message.UnloadingConstraint = ActorConstraint.internalBinaryRead(reader, reader.uint32(), options, message.UnloadingConstraint);
|
|
break;
|
|
case /* api.ActorConstraint LoadingConstraint */ 4:
|
|
message.LoadingConstraint = ActorConstraint.internalBinaryRead(reader, reader.uint32(), options, message.LoadingConstraint);
|
|
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: ActorAuthorisation, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* api.ActorConstraint UnloadingConstraint = 3; */
|
|
if (message.UnloadingConstraint)
|
|
ActorConstraint.internalBinaryWrite(message.UnloadingConstraint, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* api.ActorConstraint LoadingConstraint = 4; */
|
|
if (message.LoadingConstraint)
|
|
ActorConstraint.internalBinaryWrite(message.LoadingConstraint, writer.tag(4, 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.ActorAuthorisation
|
|
*/
|
|
export const ActorAuthorisation = new ActorAuthorisation$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class ActorConstraint$Type extends MessageType<ActorConstraint> {
|
|
constructor() {
|
|
super("api.ActorConstraint", [
|
|
{ no: 1, name: "SegmentationConstraints", kind: "message", localName: "SegmentationConstraints", jsonName: "SegmentationConstraints", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SegmentationActorConstraint, options: { "api.aggKey": "SegmentationID" } },
|
|
{ no: 3, name: "MaxBookingPeriod", kind: "message", localName: "MaxBookingPeriod", jsonName: "MaxBookingPeriod", T: () => Period },
|
|
{ no: 4, name: "IsBookingEnabledForUnknownUsers", kind: "scalar", localName: "IsBookingEnabledForUnknownUsers", jsonName: "IsBookingEnabledForUnknownUsers", T: 8 /*ScalarType.BOOL*/ },
|
|
{ no: 5, name: "CommandIdentifierEntry", kind: "enum", localName: "CommandIdentifierEntry", jsonName: "CommandIdentifierEntry", T: () => ["api.CommandIdentifierEntry", CommandIdentifierEntry] }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<ActorConstraint>): ActorConstraint {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.SegmentationConstraints = [];
|
|
message.IsBookingEnabledForUnknownUsers = false;
|
|
message.CommandIdentifierEntry = 0;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<ActorConstraint>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ActorConstraint): ActorConstraint {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* repeated api.SegmentationActorConstraint SegmentationConstraints */ 1:
|
|
message.SegmentationConstraints.push(SegmentationActorConstraint.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* api.Period MaxBookingPeriod */ 3:
|
|
message.MaxBookingPeriod = Period.internalBinaryRead(reader, reader.uint32(), options, message.MaxBookingPeriod);
|
|
break;
|
|
case /* bool IsBookingEnabledForUnknownUsers */ 4:
|
|
message.IsBookingEnabledForUnknownUsers = reader.bool();
|
|
break;
|
|
case /* api.CommandIdentifierEntry CommandIdentifierEntry */ 5:
|
|
message.CommandIdentifierEntry = reader.int32();
|
|
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: ActorConstraint, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* repeated api.SegmentationActorConstraint SegmentationConstraints = 1; */
|
|
for (let i = 0; i < message.SegmentationConstraints.length; i++)
|
|
SegmentationActorConstraint.internalBinaryWrite(message.SegmentationConstraints[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
|
/* api.Period MaxBookingPeriod = 3; */
|
|
if (message.MaxBookingPeriod)
|
|
Period.internalBinaryWrite(message.MaxBookingPeriod, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* bool IsBookingEnabledForUnknownUsers = 4; */
|
|
if (message.IsBookingEnabledForUnknownUsers !== false)
|
|
writer.tag(4, WireType.Varint).bool(message.IsBookingEnabledForUnknownUsers);
|
|
/* api.CommandIdentifierEntry CommandIdentifierEntry = 5; */
|
|
if (message.CommandIdentifierEntry !== 0)
|
|
writer.tag(5, WireType.Varint).int32(message.CommandIdentifierEntry);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.ActorConstraint
|
|
*/
|
|
export const ActorConstraint = new ActorConstraint$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SegmentationActorConstraint$Type extends MessageType<SegmentationActorConstraint> {
|
|
constructor() {
|
|
super("api.SegmentationActorConstraint", [
|
|
{ no: 1, name: "SegmentationID", kind: "scalar", localName: "SegmentationID", jsonName: "SegmentationID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1", pattern: "^[a-zA-Z0-9]+$" } } } },
|
|
{ no: 2, name: "RestrictedValueIDs", kind: "scalar", localName: "RestrictedValueIDs", jsonName: "RestrictedValueIDs", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 4, name: "Type", kind: "enum", localName: "Type", jsonName: "Type", T: () => ["api.SegmentationConstraintType", SegmentationConstraintType] },
|
|
{ no: 5, name: "AttributePath", kind: "scalar", localName: "AttributePath", jsonName: "AttributePath", T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SegmentationActorConstraint>): SegmentationActorConstraint {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.SegmentationID = "";
|
|
message.RestrictedValueIDs = [];
|
|
message.Type = 0;
|
|
message.AttributePath = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SegmentationActorConstraint>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SegmentationActorConstraint): SegmentationActorConstraint {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string SegmentationID */ 1:
|
|
message.SegmentationID = reader.string();
|
|
break;
|
|
case /* repeated string RestrictedValueIDs */ 2:
|
|
message.RestrictedValueIDs.push(reader.string());
|
|
break;
|
|
case /* api.SegmentationConstraintType Type */ 4:
|
|
message.Type = reader.int32();
|
|
break;
|
|
case /* string AttributePath */ 5:
|
|
message.AttributePath = 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: SegmentationActorConstraint, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string SegmentationID = 1; */
|
|
if (message.SegmentationID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.SegmentationID);
|
|
/* repeated string RestrictedValueIDs = 2; */
|
|
for (let i = 0; i < message.RestrictedValueIDs.length; i++)
|
|
writer.tag(2, WireType.LengthDelimited).string(message.RestrictedValueIDs[i]);
|
|
/* api.SegmentationConstraintType Type = 4; */
|
|
if (message.Type !== 0)
|
|
writer.tag(4, WireType.Varint).int32(message.Type);
|
|
/* string AttributePath = 5; */
|
|
if (message.AttributePath !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.AttributePath);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.SegmentationActorConstraint
|
|
*/
|
|
export const SegmentationActorConstraint = new SegmentationActorConstraint$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class AppointmentCommission$Type extends MessageType<AppointmentCommission> {
|
|
constructor() {
|
|
super("api.AppointmentCommission", [
|
|
{ no: 1, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
|
|
{ no: 2, name: "OrderID", kind: "scalar", localName: "OrderID", jsonName: "OrderID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 6, name: "ExecutionflowID", kind: "scalar", localName: "ExecutionflowID", jsonName: "ExecutionflowID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 3, name: "Quantities", kind: "message", localName: "Quantities", jsonName: "Quantities", repeat: 2 /*RepeatType.UNPACKED*/, T: () => QuantityByUnit },
|
|
{ no: 4, name: "OrganisationID", kind: "scalar", localName: "OrganisationID", jsonName: "OrganisationID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 5, name: "PartnerAppID", kind: "scalar", localName: "PartnerAppID", jsonName: "PartnerAppID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 7, name: "ActorID", kind: "scalar", localName: "ActorID", jsonName: "ActorID", T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<AppointmentCommission>): AppointmentCommission {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.ProjectID = "";
|
|
message.OrderID = "";
|
|
message.ExecutionflowID = "";
|
|
message.Quantities = [];
|
|
message.OrganisationID = "";
|
|
message.PartnerAppID = "";
|
|
message.ActorID = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<AppointmentCommission>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AppointmentCommission): AppointmentCommission {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string ProjectID */ 1:
|
|
message.ProjectID = reader.string();
|
|
break;
|
|
case /* string OrderID */ 2:
|
|
message.OrderID = reader.string();
|
|
break;
|
|
case /* string ExecutionflowID */ 6:
|
|
message.ExecutionflowID = reader.string();
|
|
break;
|
|
case /* repeated api.QuantityByUnit Quantities */ 3:
|
|
message.Quantities.push(QuantityByUnit.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* string OrganisationID */ 4:
|
|
message.OrganisationID = reader.string();
|
|
break;
|
|
case /* string PartnerAppID */ 5:
|
|
message.PartnerAppID = reader.string();
|
|
break;
|
|
case /* string ActorID */ 7:
|
|
message.ActorID = 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: AppointmentCommission, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string ProjectID = 1; */
|
|
if (message.ProjectID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.ProjectID);
|
|
/* string OrderID = 2; */
|
|
if (message.OrderID !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.OrderID);
|
|
/* repeated api.QuantityByUnit Quantities = 3; */
|
|
for (let i = 0; i < message.Quantities.length; i++)
|
|
QuantityByUnit.internalBinaryWrite(message.Quantities[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* string OrganisationID = 4; */
|
|
if (message.OrganisationID !== "")
|
|
writer.tag(4, WireType.LengthDelimited).string(message.OrganisationID);
|
|
/* string PartnerAppID = 5; */
|
|
if (message.PartnerAppID !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.PartnerAppID);
|
|
/* string ExecutionflowID = 6; */
|
|
if (message.ExecutionflowID !== "")
|
|
writer.tag(6, WireType.LengthDelimited).string(message.ExecutionflowID);
|
|
/* string ActorID = 7; */
|
|
if (message.ActorID !== "")
|
|
writer.tag(7, WireType.LengthDelimited).string(message.ActorID);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.AppointmentCommission
|
|
*/
|
|
export const AppointmentCommission = new AppointmentCommission$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", localName: "ProjectID", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
|
|
{ no: 2, name: "OrderID", kind: "scalar", localName: "OrderID", jsonName: "OrderID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 5, name: "ExecutionflowID", kind: "scalar", localName: "ExecutionflowID", jsonName: "ExecutionflowID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 3, name: "Quantities", kind: "message", localName: "Quantities", jsonName: "Quantities", repeat: 2 /*RepeatType.UNPACKED*/, T: () => QuantityByUnit, options: { "validate.rules": { repeated: { minItems: "1" } } } },
|
|
{ no: 4, name: "ActorID", kind: "scalar", localName: "ActorID", jsonName: "ActorID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<Commission>): Commission {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.ProjectID = "";
|
|
message.OrderID = "";
|
|
message.ExecutionflowID = "";
|
|
message.Quantities = [];
|
|
message.ActorID = "";
|
|
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:
|
|
message.ProjectID = reader.string();
|
|
break;
|
|
case /* string OrderID */ 2:
|
|
message.OrderID = reader.string();
|
|
break;
|
|
case /* string ExecutionflowID */ 5:
|
|
message.ExecutionflowID = reader.string();
|
|
break;
|
|
case /* repeated api.QuantityByUnit Quantities */ 3:
|
|
message.Quantities.push(QuantityByUnit.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* string ActorID */ 4:
|
|
message.ActorID = 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: Commission, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string ProjectID = 1; */
|
|
if (message.ProjectID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.ProjectID);
|
|
/* string OrderID = 2; */
|
|
if (message.OrderID !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.OrderID);
|
|
/* repeated api.QuantityByUnit Quantities = 3; */
|
|
for (let i = 0; i < message.Quantities.length; i++)
|
|
QuantityByUnit.internalBinaryWrite(message.Quantities[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* string ActorID = 4; */
|
|
if (message.ActorID !== "")
|
|
writer.tag(4, WireType.LengthDelimited).string(message.ActorID);
|
|
/* string ExecutionflowID = 5; */
|
|
if (message.ExecutionflowID !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.ExecutionflowID);
|
|
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();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class WMSCommission$Type extends MessageType<WMSCommission> {
|
|
constructor() {
|
|
super("api.WMSCommission", [
|
|
{ no: 1, name: "ProjectID", kind: "scalar", localName: "ProjectID", jsonName: "ProjectID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } },
|
|
{ no: 2, name: "OrderID", kind: "scalar", localName: "OrderID", jsonName: "OrderID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 5, name: "ExecutionflowID", kind: "scalar", localName: "ExecutionflowID", jsonName: "ExecutionflowID", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 4, name: "ActorID", kind: "scalar", localName: "ActorID", jsonName: "ActorID", T: 9 /*ScalarType.STRING*/, options: { "validate.rules": { string: { minLen: "1" } } } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<WMSCommission>): WMSCommission {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.ProjectID = "";
|
|
message.OrderID = "";
|
|
message.ExecutionflowID = "";
|
|
message.ActorID = "";
|
|
if (value !== undefined)
|
|
reflectionMergePartial<WMSCommission>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: WMSCommission): WMSCommission {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* string ProjectID */ 1:
|
|
message.ProjectID = reader.string();
|
|
break;
|
|
case /* string OrderID */ 2:
|
|
message.OrderID = reader.string();
|
|
break;
|
|
case /* string ExecutionflowID */ 5:
|
|
message.ExecutionflowID = reader.string();
|
|
break;
|
|
case /* string ActorID */ 4:
|
|
message.ActorID = 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: WMSCommission, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* string ProjectID = 1; */
|
|
if (message.ProjectID !== "")
|
|
writer.tag(1, WireType.LengthDelimited).string(message.ProjectID);
|
|
/* string OrderID = 2; */
|
|
if (message.OrderID !== "")
|
|
writer.tag(2, WireType.LengthDelimited).string(message.OrderID);
|
|
/* string ActorID = 4; */
|
|
if (message.ActorID !== "")
|
|
writer.tag(4, WireType.LengthDelimited).string(message.ActorID);
|
|
/* string ExecutionflowID = 5; */
|
|
if (message.ExecutionflowID !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.ExecutionflowID);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.WMSCommission
|
|
*/
|
|
export const WMSCommission = new WMSCommission$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class Booking$Type extends MessageType<Booking> {
|
|
constructor() {
|
|
super("api.Booking", [
|
|
{ no: 1, name: "AppointmentType", kind: "enum", localName: "AppointmentType", jsonName: "AppointmentType", T: () => ["api.AppointmentType", AppointmentType] },
|
|
{ no: 2, name: "Commissions", kind: "message", localName: "Commissions", jsonName: "Commissions", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Commission },
|
|
{ no: 3, name: "SegmentationSelections", kind: "message", localName: "SegmentationSelections", jsonName: "SegmentationSelections", repeat: 2 /*RepeatType.UNPACKED*/, T: () => SegmentationSelection },
|
|
{ no: 4, name: "Slots", kind: "message", localName: "Slots", jsonName: "Slots", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Slot },
|
|
{ no: 5, name: "AppointmentKind", kind: "scalar", localName: "AppointmentKind", jsonName: "AppointmentKind", T: 9 /*ScalarType.STRING*/ },
|
|
{ no: 6, name: "HasReference", kind: "scalar", localName: "HasReference", jsonName: "HasReference", T: 8 /*ScalarType.BOOL*/ },
|
|
{ no: 7, name: "Emails", kind: "scalar", localName: "Emails", jsonName: "Emails", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<Booking>): Booking {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.AppointmentType = 0;
|
|
message.Commissions = [];
|
|
message.SegmentationSelections = [];
|
|
message.Slots = [];
|
|
message.AppointmentKind = "";
|
|
message.HasReference = false;
|
|
message.Emails = [];
|
|
if (value !== undefined)
|
|
reflectionMergePartial<Booking>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Booking): Booking {
|
|
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:
|
|
message.AppointmentType = reader.int32();
|
|
break;
|
|
case /* repeated api.Commission Commissions */ 2:
|
|
message.Commissions.push(Commission.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* repeated api.SegmentationSelection SegmentationSelections */ 3:
|
|
message.SegmentationSelections.push(SegmentationSelection.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* repeated api.Slot Slots */ 4:
|
|
message.Slots.push(Slot.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* string AppointmentKind */ 5:
|
|
message.AppointmentKind = reader.string();
|
|
break;
|
|
case /* bool HasReference */ 6:
|
|
message.HasReference = reader.bool();
|
|
break;
|
|
case /* repeated string Emails */ 7:
|
|
message.Emails.push(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: Booking, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* api.AppointmentType AppointmentType = 1; */
|
|
if (message.AppointmentType !== 0)
|
|
writer.tag(1, WireType.Varint).int32(message.AppointmentType);
|
|
/* repeated api.Commission Commissions = 2; */
|
|
for (let i = 0; i < message.Commissions.length; i++)
|
|
Commission.internalBinaryWrite(message.Commissions[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
|
|
/* repeated api.SegmentationSelection SegmentationSelections = 3; */
|
|
for (let i = 0; i < message.SegmentationSelections.length; i++)
|
|
SegmentationSelection.internalBinaryWrite(message.SegmentationSelections[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
|
|
/* repeated api.Slot Slots = 4; */
|
|
for (let i = 0; i < message.Slots.length; i++)
|
|
Slot.internalBinaryWrite(message.Slots[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
|
|
/* string AppointmentKind = 5; */
|
|
if (message.AppointmentKind !== "")
|
|
writer.tag(5, WireType.LengthDelimited).string(message.AppointmentKind);
|
|
/* bool HasReference = 6; */
|
|
if (message.HasReference !== false)
|
|
writer.tag(6, WireType.Varint).bool(message.HasReference);
|
|
/* repeated string Emails = 7; */
|
|
for (let i = 0; i < message.Emails.length; i++)
|
|
writer.tag(7, WireType.LengthDelimited).string(message.Emails[i]);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.Booking
|
|
*/
|
|
export const Booking = new Booking$Type();
|
|
// @generated message type with reflection information, may provide speed optimized methods
|
|
class SlotGroup$Type extends MessageType<SlotGroup> {
|
|
constructor() {
|
|
super("api.SlotGroup", [
|
|
{ no: 1, name: "Slots", kind: "message", localName: "Slots", jsonName: "Slots", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Slot },
|
|
{ no: 2, name: "Availability", kind: "scalar", localName: "Availability", jsonName: "Availability", T: 5 /*ScalarType.INT32*/, options: { "validate.rules": { int32: { lte: 100, gte: -1 } } } }
|
|
]);
|
|
}
|
|
create(value?: PartialMessage<SlotGroup>): SlotGroup {
|
|
const message = globalThis.Object.create((this.messagePrototype!));
|
|
message.Slots = [];
|
|
message.Availability = 0;
|
|
if (value !== undefined)
|
|
reflectionMergePartial<SlotGroup>(this, message, value);
|
|
return message;
|
|
}
|
|
internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: SlotGroup): SlotGroup {
|
|
let message = target ?? this.create(), end = reader.pos + length;
|
|
while (reader.pos < end) {
|
|
let [fieldNo, wireType] = reader.tag();
|
|
switch (fieldNo) {
|
|
case /* repeated api.Slot Slots */ 1:
|
|
message.Slots.push(Slot.internalBinaryRead(reader, reader.uint32(), options));
|
|
break;
|
|
case /* int32 Availability */ 2:
|
|
message.Availability = reader.int32();
|
|
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: SlotGroup, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
|
|
/* repeated api.Slot Slots = 1; */
|
|
for (let i = 0; i < message.Slots.length; i++)
|
|
Slot.internalBinaryWrite(message.Slots[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
|
|
/* int32 Availability = 2; */
|
|
if (message.Availability !== 0)
|
|
writer.tag(2, WireType.Varint).int32(message.Availability);
|
|
let u = options.writeUnknownFields;
|
|
if (u !== false)
|
|
(u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
|
|
return writer;
|
|
}
|
|
}
|
|
/**
|
|
* @generated MessageType for protobuf message api.SlotGroup
|
|
*/
|
|
export const SlotGroup = new SlotGroup$Type();
|